← Back to branch summary

~ubuntu-branches/ubuntu/maverick/libvirt/maverick

« back to all changes in this revision

Viewing changes to src/node_device.c

  • Committer: Bazaar Package Importer
  • Author(s): Soren Hansen
  • Date: 2009-02-11 01:01:42 UTC
  • mto: (3.4.1 sid) (1.2.1 upstream) (0.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: james.westby@ubuntu.com-20090211010142-wk9mgtbw8bmp3zcb
Tags: upstream-0.6.0
Import upstream version 0.6.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/node_device.c
29
29
#include "virterror_internal.h"
30
30
#include "datatypes.h"
31
31
#include "memory.h"
32
 
 
 
32
#include "logging.h"
33
33
#include "node_device_conf.h"
34
34
#include "node_device.h"
35
35
 
 
36
#define VIR_FROM_THIS VIR_FROM_NODEDEV
 
37
 
36
38
static int dev_has_cap(const virNodeDeviceObjPtr dev, const char *cap)
37
39
{
38
40
    virNodeDevCapsDefPtr caps = dev->def->caps;
45
47
}
46
48
 
47
49
 
 
50
void nodeDeviceLock(virDeviceMonitorStatePtr driver)
 
51
{
 
52
    DEBUG("LOCK node %p", driver);
 
53
    virMutexLock(&driver->lock);
 
54
}
 
55
void nodeDeviceUnlock(virDeviceMonitorStatePtr driver)
 
56
{
 
57
    DEBUG("UNLOCK node %p", driver);
 
58
    virMutexUnlock(&driver->lock);
 
59
}
 
60
 
48
61
static int nodeNumOfDevices(virConnectPtr conn,
49
62
                            const char *cap,
50
63
                            unsigned int flags ATTRIBUTE_UNUSED)
71
84
    int ndevs = 0;
72
85
    unsigned int i;
73
86
 
74
 
    for (i = 0; i < driver->devs.count && ndevs < maxnames; i++)
 
87
    nodeDeviceLock(driver);
 
88
    for (i = 0; i < driver->devs.count && ndevs < maxnames; i++) {
 
89
        virNodeDeviceObjLock(driver->devs.objs[i]);
75
90
        if (cap == NULL ||
76
 
            dev_has_cap(driver->devs.objs[i], cap))
77
 
            if ((names[ndevs++] = strdup(driver->devs.objs[i]->def->name)) == NULL)
 
91
            dev_has_cap(driver->devs.objs[i], cap)) {
 
92
            if ((names[ndevs++] = strdup(driver->devs.objs[i]->def->name)) == NULL) {
 
93
                virNodeDeviceObjUnlock(driver->devs.objs[i]);
78
94
                goto failure;
 
95
            }
 
96
        }
 
97
        virNodeDeviceObjUnlock(driver->devs.objs[i]);
 
98
    }
 
99
    nodeDeviceUnlock(driver);
79
100
 
80
101
    return ndevs;
81
102
 
82
103
 failure:
 
104
    nodeDeviceUnlock(driver);
83
105
    --ndevs;
84
106
    while (--ndevs >= 0)
85
107
        VIR_FREE(names[ndevs]);
91
113
                                               const char *name)
92
114
{
93
115
    virDeviceMonitorStatePtr driver = conn->devMonPrivateData;
94
 
    virNodeDeviceObjPtr obj = virNodeDeviceFindByName(&driver->devs, name);
 
116
    virNodeDeviceObjPtr obj;
 
117
    virNodeDevicePtr ret = NULL;
 
118
 
 
119
    nodeDeviceLock(driver);
 
120
    obj = virNodeDeviceFindByName(&driver->devs, name);
 
121
    nodeDeviceUnlock(driver);
95
122
 
96
123
    if (!obj) {
97
124
        virNodeDeviceReportError(conn, VIR_ERR_INVALID_NODE_DEVICE,
98
125
                                 "%s", _("no node device with matching name"));
99
 
        return NULL;
 
126
        goto cleanup;
100
127
    }
101
128
 
102
 
    return virGetNodeDevice(conn, name);
 
129
    ret = virGetNodeDevice(conn, name);
103
130
 
 
131
cleanup:
 
132
    if (obj)
 
133
        virNodeDeviceObjUnlock(obj);
 
134
    return ret;
104
135
}
105
136
 
106
137
static char *nodeDeviceDumpXML(virNodeDevicePtr dev,
107
138
                               unsigned int flags ATTRIBUTE_UNUSED)
108
139
{
109
140
    virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData;
110
 
    virNodeDeviceObjPtr obj = virNodeDeviceFindByName(&driver->devs, dev->name);
 
141
    virNodeDeviceObjPtr obj;
 
142
    char *ret = NULL;
 
143
 
 
144
    nodeDeviceLock(driver);
 
145
    obj = virNodeDeviceFindByName(&driver->devs, dev->name);
 
146
    nodeDeviceUnlock(driver);
111
147
 
112
148
    if (!obj) {
113
149
        virNodeDeviceReportError(dev->conn, VIR_ERR_INVALID_NODE_DEVICE,
114
150
                              "%s", _("no node device with matching name"));
115
 
        return NULL;
 
151
        goto cleanup;
116
152
    }
117
153
 
118
 
    return virNodeDeviceDefFormat(dev->conn, obj->def);
 
154
    ret = virNodeDeviceDefFormat(dev->conn, obj->def);
 
155
 
 
156
cleanup:
 
157
    if (obj)
 
158
        virNodeDeviceObjUnlock(obj);
 
159
    return ret;
119
160
}
120
161
 
121
162
 
122
163
static char *nodeDeviceGetParent(virNodeDevicePtr dev)
123
164
{
124
165
    virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData;
125
 
    virNodeDeviceObjPtr obj = virNodeDeviceFindByName(&driver->devs, dev->name);
 
166
    virNodeDeviceObjPtr obj;
 
167
    char *ret = NULL;
 
168
 
 
169
    nodeDeviceLock(driver);
 
170
    obj = virNodeDeviceFindByName(&driver->devs, dev->name);
 
171
    nodeDeviceUnlock(driver);
126
172
 
127
173
    if (!obj) {
128
174
        virNodeDeviceReportError(dev->conn, VIR_ERR_INVALID_NODE_DEVICE,
129
175
                              "%s", _("no node device with matching name"));
130
 
        return NULL;
 
176
        goto cleanup;
131
177
    }
132
178
 
133
 
    return obj->def->parent;
 
179
    ret = strdup(obj->def->parent);
 
180
    if (!ret)
 
181
        virReportOOMError(dev->conn);
 
182
 
 
183
cleanup:
 
184
    if (obj)
 
185
        virNodeDeviceObjUnlock(obj);
 
186
    return ret;
134
187
}
135
188
 
136
189
 
137
190
static int nodeDeviceNumOfCaps(virNodeDevicePtr dev)
138
191
{
139
192
    virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData;
140
 
    virNodeDeviceObjPtr obj = virNodeDeviceFindByName(&driver->devs, dev->name);
 
193
    virNodeDeviceObjPtr obj;
141
194
    virNodeDevCapsDefPtr caps;
142
195
    int ncaps = 0;
 
196
    int ret = -1;
 
197
 
 
198
    nodeDeviceLock(driver);
 
199
    obj = virNodeDeviceFindByName(&driver->devs, dev->name);
 
200
    nodeDeviceUnlock(driver);
143
201
 
144
202
    if (!obj) {
145
203
        virNodeDeviceReportError(dev->conn, VIR_ERR_INVALID_NODE_DEVICE,
146
204
                              "%s", _("no node device with matching name"));
147
 
        return -1;
 
205
        goto cleanup;
148
206
    }
149
207
 
150
208
    for (caps = obj->def->caps; caps; caps = caps->next)
151
209
        ++ncaps;
 
210
    ret = ncaps;
152
211
 
153
 
    return ncaps;
 
212
cleanup:
 
213
    if (obj)
 
214
        virNodeDeviceObjUnlock(obj);
 
215
    return ret;
154
216
}
155
217
 
156
218
 
158
220
nodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames)
159
221
{
160
222
    virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData;
161
 
    virNodeDeviceObjPtr obj = virNodeDeviceFindByName(&driver->devs, dev->name);
 
223
    virNodeDeviceObjPtr obj;
162
224
    virNodeDevCapsDefPtr caps;
163
225
    int ncaps = 0;
 
226
    int ret = -1;
 
227
 
 
228
    nodeDeviceLock(driver);
 
229
    obj = virNodeDeviceFindByName(&driver->devs, dev->name);
 
230
    nodeDeviceUnlock(driver);
164
231
 
165
232
    if (!obj) {
166
233
        virNodeDeviceReportError(dev->conn, VIR_ERR_INVALID_NODE_DEVICE,
167
234
                              "%s", _("no node device with matching name"));
168
 
        return -1;
 
235
        goto cleanup;
169
236
    }
170
237
 
171
238
    for (caps = obj->def->caps; caps && ncaps < maxnames; caps = caps->next) {
172
239
        names[ncaps] = strdup(virNodeDevCapTypeToString(caps->type));
173
240
        if (names[ncaps++] == NULL)
174
 
            goto failure;
175
 
    }
176
 
 
177
 
    return ncaps;
178
 
 
179
 
 failure:
180
 
    --ncaps;
181
 
    while (--ncaps >= 0)
182
 
        VIR_FREE(names[ncaps]);
183
 
    return -1;
 
241
            goto cleanup;
 
242
    }
 
243
    ret = ncaps;
 
244
 
 
245
cleanup:
 
246
    if (obj)
 
247
        virNodeDeviceObjUnlock(obj);
 
248
    if (ret == -1) {
 
249
        --ncaps;
 
250
        while (--ncaps >= 0)
 
251
            VIR_FREE(names[ncaps]);
 
252
    }
 
253
    return ret;
184
254
}
185
255
 
186
256