Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Modules/resource.c

    r10 r391  
    3030
    3131static PyStructSequence_Field struct_rusage_fields[] = {
    32         {"ru_utime",    "user time used"},
    33         {"ru_stime",    "system time used"},
    34         {"ru_maxrss",   "max. resident set size"},
    35         {"ru_ixrss",    "shared memory size"},
    36         {"ru_idrss",    "unshared data size"},
    37         {"ru_isrss",    "unshared stack size"},
    38         {"ru_minflt",   "page faults not requiring I/O"},
    39         {"ru_majflt",   "page faults requiring I/O"},
    40         {"ru_nswap",    "number of swap outs"},
    41         {"ru_inblock",  "block input operations"},
    42         {"ru_oublock",  "block output operations"},
    43         {"ru_msgsnd",   "IPC messages sent"},
    44         {"ru_msgrcv",   "IPC messages received"},
    45         {"ru_nsignals", "signals received"},
    46         {"ru_nvcsw",    "voluntary context switches"},
    47         {"ru_nivcsw",   "involuntary context switches"},
    48         {0}
     32    {"ru_utime",        "user time used"},
     33    {"ru_stime",        "system time used"},
     34    {"ru_maxrss",       "max. resident set size"},
     35    {"ru_ixrss",        "shared memory size"},
     36    {"ru_idrss",        "unshared data size"},
     37    {"ru_isrss",        "unshared stack size"},
     38    {"ru_minflt",       "page faults not requiring I/O"},
     39    {"ru_majflt",       "page faults requiring I/O"},
     40    {"ru_nswap",        "number of swap outs"},
     41    {"ru_inblock",      "block input operations"},
     42    {"ru_oublock",      "block output operations"},
     43    {"ru_msgsnd",       "IPC messages sent"},
     44    {"ru_msgrcv",       "IPC messages received"},
     45    {"ru_nsignals",     "signals received"},
     46    {"ru_nvcsw",        "voluntary context switches"},
     47    {"ru_nivcsw",       "involuntary context switches"},
     48    {0}
    4949};
    5050
    5151static PyStructSequence_Desc struct_rusage_desc = {
    52         "resource.struct_rusage",       /* name */
    53         struct_rusage__doc__,   /* doc */
    54         struct_rusage_fields,   /* fields */
    55         16      /* n_in_sequence */
     52    "resource.struct_rusage",           /* name */
     53    struct_rusage__doc__,       /* doc */
     54    struct_rusage_fields,       /* fields */
     55    16          /* n_in_sequence */
    5656};
    5757
    … …  
    6262resource_getrusage(PyObject *self, PyObject *args)
    6363{
    64         int who;
    65         struct rusage ru;
    66         PyObject *result;
    67 
    68         if (!PyArg_ParseTuple(args, "i:getrusage", &who))
    69                 return NULL;
     64    int who;
     65    struct rusage ru;
     66    PyObject *result;
     67
     68    if (!PyArg_ParseTuple(args, "i:getrusage", &who))
     69        return NULL;
    7070
    7171#ifndef __OS2__
    72         if (getrusage(who, &ru) == -1) {
    73                 if (errno == EINVAL) {
    74                         PyErr_SetString(PyExc_ValueError,
    75                                         "invalid who parameter");
    76                         return NULL;
    77                 }
    78                 PyErr_SetFromErrno(ResourceError);
    79                 return NULL;
    80         }
    81 #endif
    82         result = PyStructSequence_New(&StructRUsageType);
    83         if (!result)
    84                 return NULL;
    85 
    86         PyStructSequence_SET_ITEM(result, 0,
    87                         PyFloat_FromDouble(doubletime(ru.ru_utime)));
    88         PyStructSequence_SET_ITEM(result, 1,
    89                         PyFloat_FromDouble(doubletime(ru.ru_stime)));
    90         PyStructSequence_SET_ITEM(result, 2, PyInt_FromLong(ru.ru_maxrss));
    91         PyStructSequence_SET_ITEM(result, 3, PyInt_FromLong(ru.ru_ixrss));
    92         PyStructSequence_SET_ITEM(result, 4, PyInt_FromLong(ru.ru_idrss));
    93         PyStructSequence_SET_ITEM(result, 5, PyInt_FromLong(ru.ru_isrss));
    94         PyStructSequence_SET_ITEM(result, 6, PyInt_FromLong(ru.ru_minflt));
    95         PyStructSequence_SET_ITEM(result, 7, PyInt_FromLong(ru.ru_majflt));
    96         PyStructSequence_SET_ITEM(result, 8, PyInt_FromLong(ru.ru_nswap));
    97         PyStructSequence_SET_ITEM(result, 9, PyInt_FromLong(ru.ru_inblock));
    98         PyStructSequence_SET_ITEM(result, 10, PyInt_FromLong(ru.ru_oublock));
    99         PyStructSequence_SET_ITEM(result, 11, PyInt_FromLong(ru.ru_msgsnd));
    100         PyStructSequence_SET_ITEM(result, 12, PyInt_FromLong(ru.ru_msgrcv));
    101         PyStructSequence_SET_ITEM(result, 13, PyInt_FromLong(ru.ru_nsignals));
    102         PyStructSequence_SET_ITEM(result, 14, PyInt_FromLong(ru.ru_nvcsw));
    103         PyStructSequence_SET_ITEM(result, 15, PyInt_FromLong(ru.ru_nivcsw));
    104 
    105         if (PyErr_Occurred()) {
    106                 Py_DECREF(result);
    107                 return NULL;
    108         }
    109 
    110         return result;
     72    if (getrusage(who, &ru) == -1) {
     73        if (errno == EINVAL) {
     74            PyErr_SetString(PyExc_ValueError,
     75                            "invalid who parameter");
     76            return NULL;
     77        }
     78        PyErr_SetFromErrno(ResourceError);
     79        return NULL;
     80    }
     81#endif
     82
     83    result = PyStructSequence_New(&StructRUsageType);
     84    if (!result)
     85        return NULL;
     86
     87    PyStructSequence_SET_ITEM(result, 0,
     88                    PyFloat_FromDouble(doubletime(ru.ru_utime)));
     89    PyStructSequence_SET_ITEM(result, 1,
     90                    PyFloat_FromDouble(doubletime(ru.ru_stime)));
     91    PyStructSequence_SET_ITEM(result, 2, PyInt_FromLong(ru.ru_maxrss));
     92    PyStructSequence_SET_ITEM(result, 3, PyInt_FromLong(ru.ru_ixrss));
     93    PyStructSequence_SET_ITEM(result, 4, PyInt_FromLong(ru.ru_idrss));
     94    PyStructSequence_SET_ITEM(result, 5, PyInt_FromLong(ru.ru_isrss));
     95    PyStructSequence_SET_ITEM(result, 6, PyInt_FromLong(ru.ru_minflt));
     96    PyStructSequence_SET_ITEM(result, 7, PyInt_FromLong(ru.ru_majflt));
     97    PyStructSequence_SET_ITEM(result, 8, PyInt_FromLong(ru.ru_nswap));
     98    PyStructSequence_SET_ITEM(result, 9, PyInt_FromLong(ru.ru_inblock));
     99    PyStructSequence_SET_ITEM(result, 10, PyInt_FromLong(ru.ru_oublock));
     100    PyStructSequence_SET_ITEM(result, 11, PyInt_FromLong(ru.ru_msgsnd));
     101    PyStructSequence_SET_ITEM(result, 12, PyInt_FromLong(ru.ru_msgrcv));
     102    PyStructSequence_SET_ITEM(result, 13, PyInt_FromLong(ru.ru_nsignals));
     103    PyStructSequence_SET_ITEM(result, 14, PyInt_FromLong(ru.ru_nvcsw));
     104    PyStructSequence_SET_ITEM(result, 15, PyInt_FromLong(ru.ru_nivcsw));
     105
     106    if (PyErr_Occurred()) {
     107        Py_DECREF(result);
     108        return NULL;
     109    }
     110
     111    return result;
    111112}
    112113
    … …  
    115116resource_getrlimit(PyObject *self, PyObject *args)
    116117{
    117         struct rlimit rl;
    118         int resource;
    119 
    120         if (!PyArg_ParseTuple(args, "i:getrlimit", &resource))
    121                 return NULL;
    122 
    123         if (resource < 0 || resource >= RLIM_NLIMITS) {
    124                 PyErr_SetString(PyExc_ValueError,
    125                                 "invalid resource specified");
    126                 return NULL;
    127         }
    128 
    129         if (getrlimit(resource, &rl) == -1) {
    130                 PyErr_SetFromErrno(ResourceError);
    131                 return NULL;
    132         }
     118    struct rlimit rl;
     119    int resource;
     120
     121    if (!PyArg_ParseTuple(args, "i:getrlimit", &resource))
     122        return NULL;
     123
     124    if (resource < 0 || resource >= RLIM_NLIMITS) {
     125        PyErr_SetString(PyExc_ValueError,
     126                        "invalid resource specified");
     127        return NULL;
     128    }
     129
     130    if (getrlimit(resource, &rl) == -1) {
     131        PyErr_SetFromErrno(ResourceError);
     132        return NULL;
     133    }
    133134
    134135#if defined(HAVE_LONG_LONG)
    135         if (sizeof(rl.rlim_cur) > sizeof(long)) {
    136                 return Py_BuildValue("LL",
    137                                      (PY_LONG_LONG) rl.rlim_cur,
    138                                      (PY_LONG_LONG) rl.rlim_max);
    139         }
    140 #endif
    141         return Py_BuildValue("ll", (long) rl.rlim_cur, (long) rl.rlim_max);
     136    if (sizeof(rl.rlim_cur) > sizeof(long)) {
     137        return Py_BuildValue("LL",
     138                             (PY_LONG_LONG) rl.rlim_cur,
     139                             (PY_LONG_LONG) rl.rlim_max);
     140    }
     141#endif
     142    return Py_BuildValue("ll", (long) rl.rlim_cur, (long) rl.rlim_max);
    142143}
    143144
    … …  
    145146resource_setrlimit(PyObject *self, PyObject *args)
    146147{
    147         struct rlimit rl;
    148         int resource;
    149         PyObject *curobj, *maxobj;
    150 
    151         if (!PyArg_ParseTuple(args, "i(OO):setrlimit",
    152                               &resource, &curobj, &maxobj))
    153                 return NULL;
    154 
    155         if (resource < 0 || resource >= RLIM_NLIMITS) {
    156                 PyErr_SetString(PyExc_ValueError,
    157                                 "invalid resource specified");
    158                 return NULL;
    159         }
     148    struct rlimit rl;
     149    int resource;
     150    PyObject *limits, *curobj, *maxobj;
     151
     152    if (!PyArg_ParseTuple(args, "iO:setrlimit", &resource, &limits))
     153        return NULL;
     154
     155    if (resource < 0 || resource >= RLIM_NLIMITS) {
     156        PyErr_SetString(PyExc_ValueError,
     157                        "invalid resource specified");
     158        return NULL;
     159    }
     160
     161    limits = PySequence_Tuple(limits);
     162    if (!limits)
     163        /* Here limits is a borrowed reference */
     164        return NULL;
     165
     166    if (PyTuple_GET_SIZE(limits) != 2) {
     167        PyErr_SetString(PyExc_ValueError,
     168                        "expected a tuple of 2 integers");
     169        goto error;
     170    }
     171    curobj = PyTuple_GET_ITEM(limits, 0);
     172    maxobj = PyTuple_GET_ITEM(limits, 1);
    160173
    161174#if !defined(HAVE_LARGEFILE_SUPPORT)
    162         rl.rlim_cur = PyInt_AsLong(curobj);
    163         if (rl.rlim_cur == (rlim_t)-1 && PyErr_Occurred())
    164             return NULL;
    165         rl.rlim_max = PyInt_AsLong(maxobj);
    166         if (rl.rlim_max == (rlim_t)-1 && PyErr_Occurred())
    167             return NULL;
     175    rl.rlim_cur = PyInt_AsLong(curobj);
     176    if (rl.rlim_cur == (rlim_t)-1 && PyErr_Occurred())
     177        goto error;
     178    rl.rlim_max = PyInt_AsLong(maxobj);
     179    if (rl.rlim_max == (rlim_t)-1 && PyErr_Occurred())
     180        goto error;
    168181#else
    169         /* The limits are probably bigger than a long */
    170         rl.rlim_cur = PyLong_Check(curobj) ?
    171                 PyLong_AsLongLong(curobj) : PyInt_AsLong(curobj);
    172         if (rl.rlim_cur == (rlim_t)-1 && PyErr_Occurred())
    173             return NULL;
    174         rl.rlim_max = PyLong_Check(maxobj) ?
    175                 PyLong_AsLongLong(maxobj) : PyInt_AsLong(maxobj);
    176         if (rl.rlim_max == (rlim_t)-1 && PyErr_Occurred())
    177             return NULL;
    178 #endif
    179 
    180         rl.rlim_cur = rl.rlim_cur & RLIM_INFINITY;
    181         rl.rlim_max = rl.rlim_max & RLIM_INFINITY;
    182         if (setrlimit(resource, &rl) == -1) {
    183                 if (errno == EINVAL)
    184                         PyErr_SetString(PyExc_ValueError,
    185                                         "current limit exceeds maximum limit");
    186                 else if (errno == EPERM)
    187                         PyErr_SetString(PyExc_ValueError,
    188                                         "not allowed to raise maximum limit");
    189                 else
    190                         PyErr_SetFromErrno(ResourceError);
    191                 return NULL;
    192         }
    193         Py_INCREF(Py_None);
    194         return Py_None;
     182    /* The limits are probably bigger than a long */
     183    rl.rlim_cur = PyLong_Check(curobj) ?
     184        PyLong_AsLongLong(curobj) : PyInt_AsLong(curobj);
     185    if (rl.rlim_cur == (rlim_t)-1 && PyErr_Occurred())
     186        goto error;
     187    rl.rlim_max = PyLong_Check(maxobj) ?
     188        PyLong_AsLongLong(maxobj) : PyInt_AsLong(maxobj);
     189    if (rl.rlim_max == (rlim_t)-1 && PyErr_Occurred())
     190        goto error;
     191#endif
     192
     193    rl.rlim_cur = rl.rlim_cur & RLIM_INFINITY;
     194    rl.rlim_max = rl.rlim_max & RLIM_INFINITY;
     195    if (setrlimit(resource, &rl) == -1) {
     196        if (errno == EINVAL)
     197            PyErr_SetString(PyExc_ValueError,
     198                            "current limit exceeds maximum limit");
     199        else if (errno == EPERM)
     200            PyErr_SetString(PyExc_ValueError,
     201                            "not allowed to raise maximum limit");
     202        else
     203            PyErr_SetFromErrno(ResourceError);
     204        goto error;
     205    }
     206    Py_DECREF(limits);
     207    Py_INCREF(Py_None);
     208    return Py_None;
     209
     210  error:
     211    Py_DECREF(limits);
     212    return NULL;
    195213}
    196214
    … …  
    198216resource_getpagesize(PyObject *self, PyObject *unused)
    199217{
    200         long pagesize = 0;
     218    long pagesize = 0;
    201219#if defined(HAVE_GETPAGESIZE)
    202         pagesize = getpagesize();
     220    pagesize = getpagesize();
    203221#elif defined(HAVE_SYSCONF)
    204222#if defined(_SC_PAGE_SIZE)
    205         pagesize = sysconf(_SC_PAGE_SIZE);
     223    pagesize = sysconf(_SC_PAGE_SIZE);
    206224#else
    207         /* Irix 5.3 has _SC_PAGESIZE, but not _SC_PAGE_SIZE */
    208         pagesize = sysconf(_SC_PAGESIZE);
    209 #endif
    210 #endif
    211         return Py_BuildValue("i", pagesize);
     225    /* Irix 5.3 has _SC_PAGESIZE, but not _SC_PAGE_SIZE */
     226    pagesize = sysconf(_SC_PAGESIZE);
     227#endif
     228#endif
     229    return Py_BuildValue("i", pagesize);
    212230
    213231}
    … …  
    217235static struct PyMethodDef
    218236resource_methods[] = {
    219         {"getrusage",    resource_getrusage,   METH_VARARGS},
    220         {"getrlimit",    resource_getrlimit,   METH_VARARGS},
    221         {"setrlimit",    resource_setrlimit,   METH_VARARGS},
    222         {"getpagesize",  resource_getpagesize, METH_NOARGS},
    223         {NULL, NULL}                         /* sentinel */
     237    {"getrusage",    resource_getrusage,   METH_VARARGS},
     238    {"getrlimit",    resource_getrlimit,   METH_VARARGS},
     239    {"setrlimit",    resource_setrlimit,   METH_VARARGS},
     240    {"getpagesize",  resource_getpagesize, METH_NOARGS},
     241    {NULL, NULL}                             /* sentinel */
    224242};
    225243
    … …  
    230248initresource(void)
    231249{
    232         PyObject *m, *v;
    233 
    234         /* Create the module and add the functions */
    235         m = Py_InitModule("resource", resource_methods);
    236         if (m == NULL)
    237                 return;
    238 
    239         /* Add some symbolic constants to the module */
    240         if (ResourceError == NULL) {
    241                 ResourceError = PyErr_NewException("resource.error",
    242                                                    NULL, NULL);
    243         }
    244         Py_INCREF(ResourceError);
    245         PyModule_AddObject(m, "error", ResourceError);
    246         if (!initialized)
    247                 PyStructSequence_InitType(&StructRUsageType,
    248                                           &struct_rusage_desc);
    249         Py_INCREF(&StructRUsageType);
    250         PyModule_AddObject(m, "struct_rusage",
    251                            (PyObject*) &StructRUsageType);
    252 
    253         /* insert constants */
     250    PyObject *m, *v;
     251
     252    /* Create the module and add the functions */
     253    m = Py_InitModule("resource", resource_methods);
     254    if (m == NULL)
     255        return;
     256
     257    /* Add some symbolic constants to the module */
     258    if (ResourceError == NULL) {
     259        ResourceError = PyErr_NewException("resource.error",
     260                                           NULL, NULL);
     261    }
     262    Py_INCREF(ResourceError);
     263    PyModule_AddObject(m, "error", ResourceError);
     264    if (!initialized)
     265        PyStructSequence_InitType(&StructRUsageType,
     266                                  &struct_rusage_desc);
     267    Py_INCREF(&StructRUsageType);
     268    PyModule_AddObject(m, "struct_rusage",
     269                       (PyObject*) &StructRUsageType);
     270
     271    /* insert constants */
    254272#ifdef RLIMIT_CPU
    255         PyModule_AddIntConstant(m, "RLIMIT_CPU", RLIMIT_CPU);
     273    PyModule_AddIntConstant(m, "RLIMIT_CPU", RLIMIT_CPU);
    256274#endif
    257275
    258276#ifdef RLIMIT_FSIZE
    259         PyModule_AddIntConstant(m, "RLIMIT_FSIZE", RLIMIT_FSIZE);
     277    PyModule_AddIntConstant(m, "RLIMIT_FSIZE", RLIMIT_FSIZE);
    260278#endif
    261279
    262280#ifdef RLIMIT_DATA
    263         PyModule_AddIntConstant(m, "RLIMIT_DATA", RLIMIT_DATA);
     281    PyModule_AddIntConstant(m, "RLIMIT_DATA", RLIMIT_DATA);
    264282#endif
    265283
    266284#ifdef RLIMIT_STACK
    267         PyModule_AddIntConstant(m, "RLIMIT_STACK", RLIMIT_STACK);
     285    PyModule_AddIntConstant(m, "RLIMIT_STACK", RLIMIT_STACK);
    268286#endif
    269287
    270288#ifdef RLIMIT_CORE
    271         PyModule_AddIntConstant(m, "RLIMIT_CORE", RLIMIT_CORE);
     289    PyModule_AddIntConstant(m, "RLIMIT_CORE", RLIMIT_CORE);
    272290#endif
    273291
    274292#ifdef RLIMIT_NOFILE
    275         PyModule_AddIntConstant(m, "RLIMIT_NOFILE", RLIMIT_NOFILE);
     293    PyModule_AddIntConstant(m, "RLIMIT_NOFILE", RLIMIT_NOFILE);
    276294#endif
    277295
    278296#ifdef RLIMIT_OFILE
    279         PyModule_AddIntConstant(m, "RLIMIT_OFILE", RLIMIT_OFILE);
     297    PyModule_AddIntConstant(m, "RLIMIT_OFILE", RLIMIT_OFILE);
    280298#endif
    281299
    282300#ifdef RLIMIT_VMEM
    283         PyModule_AddIntConstant(m, "RLIMIT_VMEM", RLIMIT_VMEM);
     301    PyModule_AddIntConstant(m, "RLIMIT_VMEM", RLIMIT_VMEM);
    284302#endif
    285303
    286304#ifdef RLIMIT_AS
    287         PyModule_AddIntConstant(m, "RLIMIT_AS", RLIMIT_AS);
     305    PyModule_AddIntConstant(m, "RLIMIT_AS", RLIMIT_AS);
    288306#endif
    289307
    290308#ifdef RLIMIT_RSS
    291         PyModule_AddIntConstant(m, "RLIMIT_RSS", RLIMIT_RSS);
     309    PyModule_AddIntConstant(m, "RLIMIT_RSS", RLIMIT_RSS);
    292310#endif
    293311
    294312#ifdef RLIMIT_NPROC
    295         PyModule_AddIntConstant(m, "RLIMIT_NPROC", RLIMIT_NPROC);
     313    PyModule_AddIntConstant(m, "RLIMIT_NPROC", RLIMIT_NPROC);
    296314#endif
    297315
    298316#ifdef RLIMIT_MEMLOCK
    299         PyModule_AddIntConstant(m, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK);
     317    PyModule_AddIntConstant(m, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK);
    300318#endif
    301319
    302320#ifdef RLIMIT_SBSIZE
    303         PyModule_AddIntConstant(m, "RLIMIT_SBSIZE", RLIMIT_SBSIZE);
     321    PyModule_AddIntConstant(m, "RLIMIT_SBSIZE", RLIMIT_SBSIZE);
    304322#endif
    305323
    306324#ifdef RUSAGE_SELF
    307         PyModule_AddIntConstant(m, "RUSAGE_SELF", RUSAGE_SELF);
     325    PyModule_AddIntConstant(m, "RUSAGE_SELF", RUSAGE_SELF);
    308326#endif
    309327
    310328#ifdef RUSAGE_CHILDREN
    311         PyModule_AddIntConstant(m, "RUSAGE_CHILDREN", RUSAGE_CHILDREN);
     329    PyModule_AddIntConstant(m, "RUSAGE_CHILDREN", RUSAGE_CHILDREN);
    312330#endif
    313331
    314332#ifdef RUSAGE_BOTH
    315         PyModule_AddIntConstant(m, "RUSAGE_BOTH", RUSAGE_BOTH);
     333    PyModule_AddIntConstant(m, "RUSAGE_BOTH", RUSAGE_BOTH);
    316334#endif
    317335
    318336#if defined(HAVE_LONG_LONG)
    319         if (sizeof(RLIM_INFINITY) > sizeof(long)) {
    320                 v = PyLong_FromLongLong((PY_LONG_LONG) RLIM_INFINITY);
    321         } else
    322 #endif
    323         {
    324                 v = PyInt_FromLong((long) RLIM_INFINITY);
    325         }
    326         if (v) {
    327                 PyModule_AddObject(m, "RLIM_INFINITY", v);
    328         }
    329         initialized = 1;
    330 }
     337    if (sizeof(RLIM_INFINITY) > sizeof(long)) {
     338        v = PyLong_FromLongLong((PY_LONG_LONG) RLIM_INFINITY);
     339    } else
     340#endif
     341    {
     342        v = PyInt_FromLong((long) RLIM_INFINITY);
     343    }
     344    if (v) {
     345        PyModule_AddObject(m, "RLIM_INFINITY", v);
     346    }
     347    initialized = 1;
     348}
Note: See TracChangeset for help on using the changeset viewer.