cddl/contrib/opensolaris/lib/pyzfs/common/ioctl.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <Python.h>
  27 #include <sys/zfs_ioctl.h>
  28 #include <sys/fs/zfs.h>
  29 #include <strings.h>
  30 #include <unistd.h>
  31 #include <libnvpair.h>
  32 #include <idmap.h>
  33 #include <zone.h>
  34 #include <libintl.h>
  35 #include <libzfs.h>
  36 #include <libzfs_impl.h>
  37 #include "zfs_prop.h"
  38
  39 static PyObject *ZFSError;
  40 static int zfsdevfd;
  41
  42 #ifdef __lint
  43 #define dgettext(x, y) y
  44 #endif
  45
  46 #define _(s) dgettext(TEXT_DOMAIN, s)
  47
  48 #ifdef sun
  49 extern int sid_to_id(char *sid, boolean_t user, uid_t *id);
  50 #endif  /* sun */
  51
  52 /*PRINTFLIKE1*/
  53 static void
  54 seterr(char *fmt, ...)
  55 {
  56         char errstr[1024];
  57         va_list v;
  58
  59         va_start(v, fmt);
  60         (void) vsnprintf(errstr, sizeof (errstr), fmt, v);
  61         va_end(v);
  62
  63         PyErr_SetObject(ZFSError, Py_BuildValue("is", errno, errstr));
  64 }
  65
  66 static char cmdstr[HIS_MAX_RECORD_LEN];
  67
  68 static int
  69 ioctl_with_cmdstr(unsigned long ioc, zfs_cmd_t *zc)
  70 {
  71         int err;
  72
  73         if (cmdstr[0])
  74                 zc->zc_history = (uint64_t)(uintptr_t)cmdstr;
  75         err = ioctl(zfsdevfd, ioc, zc);
  76         cmdstr[0] = '\0';
  77         return (err);
  78 }
  79
  80 static PyObject *
  81 nvl2py(nvlist_t *nvl)
  82 {
  83         PyObject *pyo;
  84         nvpair_t *nvp;
  85
  86         pyo = PyDict_New();
  87
  88         for (nvp = nvlist_next_nvpair(nvl, NULL); nvp;
  89             nvp = nvlist_next_nvpair(nvl, nvp)) {
  90                 PyObject *pyval;
  91                 char *sval;
  92                 uint64_t ival;
  93                 boolean_t bval;
  94                 nvlist_t *nval;
  95
  96                 switch (nvpair_type(nvp)) {
  97                 case DATA_TYPE_STRING:
  98                         (void) nvpair_value_string(nvp, &sval);
  99                         pyval = Py_BuildValue("s", sval);
 100                         break;
 101
 102                 case DATA_TYPE_UINT64:
 103                         (void) nvpair_value_uint64(nvp, &ival);
 104                         pyval = Py_BuildValue("K", ival);
 105                         break;
 106
 107                 case DATA_TYPE_NVLIST:
 108                         (void) nvpair_value_nvlist(nvp, &nval);
 109                         pyval = nvl2py(nval);
 110                         break;
 111
 112                 case DATA_TYPE_BOOLEAN:
 113                         Py_INCREF(Py_None);
 114                         pyval = Py_None;
 115                         break;
 116
 117                 case DATA_TYPE_BOOLEAN_VALUE:
 118                         (void) nvpair_value_boolean_value(nvp, &bval);
 119                         pyval = Py_BuildValue("i", bval);
 120                         break;
 121
 122                 default:
 123                         PyErr_SetNone(PyExc_ValueError);
 124                         Py_DECREF(pyo);
 125                         return (NULL);
 126                 }
 127
 128                 PyDict_SetItemString(pyo, nvpair_name(nvp), pyval);
 129                 Py_DECREF(pyval);
 130         }
 131
 132         return (pyo);
 133 }
 134
 135 static nvlist_t *
 136 dict2nvl(PyObject *d)
 137 {
 138         nvlist_t *nvl;
 139         int err;
 140         PyObject *key, *value;
 141 //      int pos = 0;
 142         Py_ssize_t pos = 0;
 143
 144         if (!PyDict_Check(d)) {
 145                 PyErr_SetObject(PyExc_ValueError, d);
 146                 return (NULL);
 147         }
 148
 149         err = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0);
 150         assert(err == 0);
 151
 152         while (PyDict_Next(d, &pos, &key, &value)) {
 153                 char *keystr = PyString_AsString(key);
 154                 if (keystr == NULL) {
 155                         PyErr_SetObject(PyExc_KeyError, key);
 156                         nvlist_free(nvl);
 157                         return (NULL);
 158                 }
 159
 160                 if (PyDict_Check(value)) {
 161                         nvlist_t *valnvl = dict2nvl(value);
 162                         err = nvlist_add_nvlist(nvl, keystr, valnvl);
 163                         nvlist_free(valnvl);
 164                 } else if (value == Py_None) {
 165                         err = nvlist_add_boolean(nvl, keystr);
 166                 } else if (PyString_Check(value)) {
 167                         char *valstr = PyString_AsString(value);
 168                         err = nvlist_add_string(nvl, keystr, valstr);
 169                 } else if (PyInt_Check(value)) {
 170                         uint64_t valint = PyInt_AsUnsignedLongLongMask(value);
 171                         err = nvlist_add_uint64(nvl, keystr, valint);
 172                 } else if (PyBool_Check(value)) {
 173                         boolean_t valbool = value == Py_True ? B_TRUE : B_FALSE;
 174                         err = nvlist_add_boolean_value(nvl, keystr, valbool);
 175                 } else {
 176                         PyErr_SetObject(PyExc_ValueError, value);
 177                         nvlist_free(nvl);
 178                         return (NULL);
 179                 }
 180                 assert(err == 0);
 181         }
 182
 183         return (nvl);
 184 }
 185
 186 static PyObject *
 187 fakepropval(uint64_t value)
 188 {
 189         PyObject *d = PyDict_New();
 190         PyDict_SetItemString(d, "value", Py_BuildValue("K", value));
 191         return (d);
 192 }
 193
 194 static void
 195 add_ds_props(zfs_cmd_t *zc, PyObject *nvl)
 196 {
 197         dmu_objset_stats_t *s = &zc->zc_objset_stats;
 198         PyDict_SetItemString(nvl, "numclones",
 199             fakepropval(s->dds_num_clones));
 200         PyDict_SetItemString(nvl, "issnap",
 201             fakepropval(s->dds_is_snapshot));
 202         PyDict_SetItemString(nvl, "inconsistent",
 203             fakepropval(s->dds_inconsistent));
 204 }
 205
 206 /* On error, returns NULL but does not set python exception. */
 207 static PyObject *
 208 ioctl_with_dstnv(unsigned long ioc, zfs_cmd_t *zc)
 209 {
 210         int nvsz = 2048;
 211         void *nvbuf;
 212         PyObject *pynv = NULL;
 213
 214 again:
 215         nvbuf = malloc(nvsz);
 216         zc->zc_nvlist_dst_size = nvsz;
 217         zc->zc_nvlist_dst = (uintptr_t)nvbuf;
 218
 219         if (ioctl(zfsdevfd, ioc, zc) == 0) {
 220                 nvlist_t *nvl;
 221
 222                 errno = nvlist_unpack(nvbuf, zc->zc_nvlist_dst_size, &nvl, 0);
 223                 if (errno == 0) {
 224                         pynv = nvl2py(nvl);
 225                         nvlist_free(nvl);
 226                 }
 227         } else if (errno == ENOMEM) {
 228                 free(nvbuf);
 229                 nvsz = zc->zc_nvlist_dst_size;
 230                 goto again;
 231         }
 232         free(nvbuf);
 233         return (pynv);
 234 }
 235
 236 static PyObject *
 237 py_next_dataset(PyObject *self, PyObject *args)
 238 {
 239         unsigned long ioc;
 240         uint64_t cookie;
 241         zfs_cmd_t zc = { 0 };
 242         int snaps;
 243         char *name;
 244         PyObject *nvl;
 245         PyObject *ret = NULL;
 246
 247         if (!PyArg_ParseTuple(args, "siK", &name, &snaps, &cookie))
 248                 return (NULL);
 249
 250         (void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name));
 251         zc.zc_cookie = cookie;
 252
 253         if (snaps)
 254                 ioc = ZFS_IOC_SNAPSHOT_LIST_NEXT;
 255         else
 256                 ioc = ZFS_IOC_DATASET_LIST_NEXT;
 257
 258         nvl = ioctl_with_dstnv(ioc, &zc);
 259         if (nvl) {
 260                 add_ds_props(&zc, nvl);
 261                 ret = Py_BuildValue("sKO", zc.zc_name, zc.zc_cookie, nvl);
 262                 Py_DECREF(nvl);
 263         } else if (errno == ESRCH) {
 264                 PyErr_SetNone(PyExc_StopIteration);
 265         } else {
 266                 if (snaps)
 267                         seterr(_("cannot get snapshots of %s"), name);
 268                 else
 269                         seterr(_("cannot get child datasets of %s"), name);
 270         }
 271         return (ret);
 272 }
 273
 274 static PyObject *
 275 py_dataset_props(PyObject *self, PyObject *args)
 276 {
 277         zfs_cmd_t zc = { 0 };
 278         int snaps;
 279         char *name;
 280         PyObject *nvl;
 281
 282         if (!PyArg_ParseTuple(args, "s", &name))
 283                 return (NULL);
 284
 285         (void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name));
 286
 287         nvl = ioctl_with_dstnv(ZFS_IOC_OBJSET_STATS, &zc);
 288         if (nvl) {
 289                 add_ds_props(&zc, nvl);
 290         } else {
 291                 seterr(_("cannot access dataset %s"), name);
 292         }
 293         return (nvl);
 294 }
 295
 296 static PyObject *
 297 py_get_fsacl(PyObject *self, PyObject *args)
 298 {
 299         zfs_cmd_t zc = { 0 };
 300         char *name;
 301         PyObject *nvl;
 302
 303         if (!PyArg_ParseTuple(args, "s", &name))
 304                 return (NULL);
 305
 306         (void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name));
 307
 308         nvl = ioctl_with_dstnv(ZFS_IOC_GET_FSACL, &zc);
 309         if (nvl == NULL)
 310                 seterr(_("cannot get permissions on %s"), name);
 311
 312         return (nvl);
 313 }
 314
 315 static PyObject *
 316 py_set_fsacl(PyObject *self, PyObject *args)
 317 {
 318         int un;
 319         size_t nvsz;
 320         zfs_cmd_t zc = { 0 };
 321         char *name, *nvbuf;
 322         PyObject *dict, *file;
 323         nvlist_t *nvl;
 324         int err;
 325
 326         if (!PyArg_ParseTuple(args, "siO!", &name, &un,
 327             &PyDict_Type, &dict))
 328                 return (NULL);
 329
 330         nvl = dict2nvl(dict);
 331         if (nvl == NULL)
 332                 return (NULL);
 333
 334         err = nvlist_size(nvl, &nvsz, NV_ENCODE_NATIVE);
 335         assert(err == 0);
 336         nvbuf = malloc(nvsz);
 337         err = nvlist_pack(nvl, &nvbuf, &nvsz, NV_ENCODE_NATIVE, 0);
 338         assert(err == 0);
 339
 340         (void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name));
 341         zc.zc_nvlist_src_size = nvsz;
 342         zc.zc_nvlist_src = (uintptr_t)nvbuf;
 343         zc.zc_perm_action = un;
 344
 345         err = ioctl_with_cmdstr(ZFS_IOC_SET_FSACL, &zc);
 346         free(nvbuf);
 347         if (err) {
 348                 seterr(_("cannot set permissions on %s"), name);
 349                 return (NULL);
 350         }
 351
 352         Py_RETURN_NONE;
 353 }
 354
 355 static PyObject *
 356 py_userspace_many(PyObject *self, PyObject *args)
 357 {
 358         zfs_cmd_t zc = { 0 };
 359         zfs_userquota_prop_t type;
 360         char *name, *propname;
 361         int bufsz = 1<<20;
 362         void *buf;
 363         PyObject *dict, *file;
 364         int error;
 365
 366         if (!PyArg_ParseTuple(args, "ss", &name, &propname))
 367                 return (NULL);
 368
 369         for (type = 0; type < ZFS_NUM_USERQUOTA_PROPS; type++)
 370                 if (strcmp(propname, zfs_userquota_prop_prefixes[type]) == 0)
 371                         break;
 372         if (type == ZFS_NUM_USERQUOTA_PROPS) {
 373                 PyErr_SetString(PyExc_KeyError, propname);
 374                 return (NULL);
 375         }
 376
 377         dict = PyDict_New();
 378         buf = malloc(bufsz);
 379
 380         (void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name));
 381         zc.zc_objset_type = type;
 382         zc.zc_cookie = 0;
 383
 384         while (1) {
 385                 zfs_useracct_t *zua = buf;
 386
 387                 zc.zc_nvlist_dst = (uintptr_t)buf;
 388                 zc.zc_nvlist_dst_size = bufsz;
 389
 390                 error = ioctl(zfsdevfd, ZFS_IOC_USERSPACE_MANY, &zc);
 391                 if (error || zc.zc_nvlist_dst_size == 0)
 392                         break;
 393
 394                 while (zc.zc_nvlist_dst_size > 0) {
 395                         PyObject *pykey, *pyval;
 396
 397                         pykey = Py_BuildValue("sI",
 398                             zua->zu_domain, zua->zu_rid);
 399                         pyval = Py_BuildValue("K", zua->zu_space);
 400                         PyDict_SetItem(dict, pykey, pyval);
 401                         Py_DECREF(pykey);
 402                         Py_DECREF(pyval);
 403
 404                         zua++;
 405                         zc.zc_nvlist_dst_size -= sizeof (zfs_useracct_t);
 406                 }
 407         }
 408
 409         free(buf);
 410
 411         if (error != 0) {
 412                 Py_DECREF(dict);
 413                 seterr(_("cannot get %s property on %s"), propname, name);
 414                 return (NULL);
 415         }
 416
 417         return (dict);
 418 }
 419
 420 static PyObject *
 421 py_userspace_upgrade(PyObject *self, PyObject *args)
 422 {
 423         zfs_cmd_t zc = { 0 };
 424         char *name;
 425         int error;
 426
 427         if (!PyArg_ParseTuple(args, "s", &name))
 428                 return (NULL);
 429
 430         (void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name));
 431         error = ioctl(zfsdevfd, ZFS_IOC_USERSPACE_UPGRADE, &zc);
 432
 433         if (error != 0) {
 434                 seterr(_("cannot initialize user accounting information on %s"),
 435                     name);
 436                 return (NULL);
 437         }
 438
 439         Py_RETURN_NONE;
 440 }
 441
 442 static PyObject *
 443 py_sid_to_id(PyObject *self, PyObject *args)
 444 {
 445 #ifdef sun
 446         char *sid;
 447         int err, isuser;
 448         uid_t id;
 449
 450         if (!PyArg_ParseTuple(args, "si", &sid, &isuser))
 451                 return (NULL);
 452
 453         err = sid_to_id(sid, isuser, &id);
 454         if (err) {
 455                 PyErr_SetString(PyExc_KeyError, sid);
 456                 return (NULL);
 457         }
 458
 459         return (Py_BuildValue("I", id));
 460 #else   /* sun */
 461         return (NULL);
 462 #endif  /* sun */
 463 }
 464
 465 /*
 466  * Translate the sid string ("S-1-...") to the user@domain name, if
 467  * possible.  There should be a better way to do this, but for now we
 468  * just translate to the (possibly ephemeral) uid and then back again.
 469  */
 470 static PyObject *
 471 py_sid_to_name(PyObject *self, PyObject *args)
 472 {
 473 #ifdef sun
 474         char *sid;
 475         int err, isuser;
 476         uid_t id;
 477         char *name, *domain;
 478         char buf[256];
 479
 480         if (!PyArg_ParseTuple(args, "si", &sid, &isuser))
 481                 return (NULL);
 482
 483         err = sid_to_id(sid, isuser, &id);
 484         if (err) {
 485                 PyErr_SetString(PyExc_KeyError, sid);
 486                 return (NULL);
 487         }
 488
 489         if (isuser) {
 490                 err = idmap_getwinnamebyuid(id,
 491                     IDMAP_REQ_FLG_USE_CACHE, &name, &domain);
 492         } else {
 493                 err = idmap_getwinnamebygid(id,
 494                     IDMAP_REQ_FLG_USE_CACHE, &name, &domain);
 495         }
 496         if (err != IDMAP_SUCCESS) {
 497                 PyErr_SetString(PyExc_KeyError, sid);
 498                 return (NULL);
 499         }
 500         (void) snprintf(buf, sizeof (buf), "%s@%s", name, domain);
 501         free(name);
 502         free(domain);
 503
 504         return (Py_BuildValue("s", buf));
 505 #else   /* sun */
 506         return(NULL);
 507 #endif  /* sun */
 508 }
 509
 510 static PyObject *
 511 py_isglobalzone(PyObject *self, PyObject *args)
 512 {
 513         return (Py_BuildValue("i", getzoneid() == GLOBAL_ZONEID));
 514 }
 515
 516 static PyObject *
 517 py_set_cmdstr(PyObject *self, PyObject *args)
 518 {
 519         char *str;
 520
 521         if (!PyArg_ParseTuple(args, "s", &str))
 522                 return (NULL);
 523
 524         (void) strlcpy(cmdstr, str, sizeof (cmdstr));
 525
 526         Py_RETURN_NONE;
 527 }
 528
 529 static PyObject *
 530 py_get_proptable(PyObject *self, PyObject *args)
 531 {
 532         zprop_desc_t *t = zfs_prop_get_table();
 533         PyObject *d = PyDict_New();
 534         zfs_prop_t i;
 535
 536         for (i = 0; i < ZFS_NUM_PROPS; i++) {
 537                 zprop_desc_t *p = &t[i];
 538                 PyObject *tuple;
 539                 static const char *typetable[] =
 540                     {"number", "string", "index"};
 541                 static const char *attrtable[] =
 542                     {"default", "readonly", "inherit", "onetime"};
 543                 PyObject *indextable;
 544
 545                 if (p->pd_proptype == PROP_TYPE_INDEX) {
 546                         const zprop_index_t *it = p->pd_table;
 547                         indextable = PyDict_New();
 548                         int j;
 549                         for (j = 0; it[j].pi_name; j++) {
 550                                 PyDict_SetItemString(indextable,
 551                                     it[j].pi_name,
 552                                     Py_BuildValue("K", it[j].pi_value));
 553                         }
 554                 } else {
 555                         Py_INCREF(Py_None);
 556                         indextable = Py_None;
 557                 }
 558
 559                 tuple = Py_BuildValue("sissKsissiiO",
 560                     p->pd_name, p->pd_propnum, typetable[p->pd_proptype],
 561                     p->pd_strdefault, p->pd_numdefault,
 562                     attrtable[p->pd_attr], p->pd_types,
 563                     p->pd_values, p->pd_colname,
 564                     p->pd_rightalign, p->pd_visible, indextable);
 565                 PyDict_SetItemString(d, p->pd_name, tuple);
 566                 Py_DECREF(tuple);
 567         }
 568
 569         return (d);
 570 }
 571
 572 static PyMethodDef zfsmethods[] = {
 573         {"next_dataset", py_next_dataset, METH_VARARGS,
 574             "Get next child dataset or snapshot."},
 575         {"get_fsacl", py_get_fsacl, METH_VARARGS, "Get allowed permissions."},
 576         {"set_fsacl", py_set_fsacl, METH_VARARGS, "Set allowed permissions."},
 577         {"userspace_many", py_userspace_many, METH_VARARGS,
 578             "Get user space accounting."},
 579         {"userspace_upgrade", py_userspace_upgrade, METH_VARARGS,
 580             "Upgrade fs to enable user space accounting."},
 581         {"set_cmdstr", py_set_cmdstr, METH_VARARGS,
 582             "Set command string for history logging."},
 583         {"dataset_props", py_dataset_props, METH_VARARGS,
 584             "Get dataset properties."},
 585         {"get_proptable", py_get_proptable, METH_NOARGS,
 586             "Get property table."},
 587         /* Below are not really zfs-specific: */
 588         {"sid_to_id", py_sid_to_id, METH_VARARGS, "Map SID to UID/GID."},
 589         {"sid_to_name", py_sid_to_name, METH_VARARGS,
 590             "Map SID to name@domain."},
 591         {"isglobalzone", py_isglobalzone, METH_NOARGS,
 592             "Determine if this is the global zone."},
 593         {NULL, NULL, 0, NULL}
 594 };
 595
 596 void
 597 initioctl(void)
 598 {
 599         PyObject *zfs_ioctl = Py_InitModule("zfs.ioctl", zfsmethods);
 600         PyObject *zfs_util = PyImport_ImportModule("zfs.util");
 601         PyObject *devfile;
 602
 603         if (zfs_util == NULL)
 604                 return;
 605
 606         ZFSError = PyObject_GetAttrString(zfs_util, "ZFSError");
 607         devfile = PyObject_GetAttrString(zfs_util, "dev");
 608         zfsdevfd = PyObject_AsFileDescriptor(devfile);
 609
 610         zfs_prop_init();
 611 }