This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9745

revlog: use size_t for nodetree capacity
ClosedPublic

Authored by quark on Jan 12 2021, 5:51 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGfcc324a228fe: revlog: use size_t for nodetree capacity
Summary

This allows handling revlog containing more than 33554432 (INT_MAX /
sizeof(nodetreenode)) revisions on x64 platforms.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

quark created this revision.Jan 12 2021, 5:51 PM
quark added a commit: rHGfcc324a228fe: revlog: use size_t for nodetree capacity.Jan 13 2021, 1:27 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGfcc324a228fe: revlog: use size_t for nodetree capacity (authored by quark). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/cext/revlog.c (15 lines)

Diff 24748

mercurial/cext/revlog.c

/* /*
parsers.c - efficient content parsing parsers.c - efficient content parsing
Copyright 2008 Matt Mackall <mpm@selenic.com> and others Copyright 2008 Matt Mackall <mpm@selenic.com> and others
This software may be used and distributed according to the terms of This software may be used and distributed according to the terms of
the GNU General Public License, incorporated herein by reference. the GNU General Public License, incorporated herein by reference.
*/ */
#define PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN
#include <Python.h> #include <Python.h>
#include <assert.h> #include <assert.h>
#include <ctype.h> #include <ctype.h>
#include <limits.h> #include <limits.h>
#include <stddef.h> #include <stddef.h>
#include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "bitmanipulation.h" #include "bitmanipulation.h"
#include "charencode.h" #include "charencode.h"
#include "revlog.h" #include "revlog.h"
#include "util.h" #include "util.h"
* Positive value is index of the next node in the trie * Positive value is index of the next node in the trie
* Negative value is a leaf: -(rev + 2) * Negative value is a leaf: -(rev + 2)
* Zero is empty * Zero is empty
*/ */
typedef struct { typedef struct {
indexObject *index; indexObject *index;
nodetreenode *nodes; nodetreenode *nodes;
Py_ssize_t nodelen; Py_ssize_t nodelen;
unsigned length; /* # nodes in use */ size_t length; /* # nodes in use */
unsigned capacity; /* # nodes allocated */ size_t capacity; /* # nodes allocated */
int depth; /* maximum depth of tree */ int depth; /* maximum depth of tree */
int splits; /* # splits performed */ int splits; /* # splits performed */
} nodetree; } nodetree;
typedef struct { typedef struct {
PyObject_HEAD /* ; */ PyObject_HEAD /* ; */
nodetree nt; nodetree nt;
} nodetreeObject; } nodetreeObject;
/* /*
} }
/* multiple matches against an ambiguous prefix */ /* multiple matches against an ambiguous prefix */
return -4; return -4;
} }
static int nt_new(nodetree *self) static int nt_new(nodetree *self)
{ {
if (self->length == self->capacity) { if (self->length == self->capacity) {
unsigned newcapacity; size_t newcapacity;
nodetreenode *newnodes; nodetreenode *newnodes;
newcapacity = self->capacity * 2; newcapacity = self->capacity * 2;
if (newcapacity >= INT_MAX / sizeof(nodetreenode)) { if (newcapacity >= SIZE_MAX / sizeof(nodetreenode)) {
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
"overflow in nt_new"); "overflow in nt_new");
return -1; return -1;
} }
newnodes = newnodes =
realloc(self->nodes, newcapacity * sizeof(nodetreenode)); realloc(self->nodes, newcapacity * sizeof(nodetreenode));
if (newnodes == NULL) { if (newnodes == NULL) {
PyErr_SetString(PyExc_MemoryError, "out of memory"); PyErr_SetString(PyExc_MemoryError, "out of memory");
self->index = index; self->index = index;
/* The input capacity is in terms of revisions, while the field is in /* The input capacity is in terms of revisions, while the field is in
* terms of nodetree nodes. */ * terms of nodetree nodes. */
self->capacity = (capacity < 4 ? 4 : capacity / 2); self->capacity = (capacity < 4 ? 4 : capacity / 2);
self->nodelen = index->nodelen; self->nodelen = index->nodelen;
self->depth = 0; self->depth = 0;
self->splits = 0; self->splits = 0;
if ((size_t)self->capacity > INT_MAX / sizeof(nodetreenode)) { if (self->capacity > SIZE_MAX / sizeof(nodetreenode)) {
PyErr_SetString(PyExc_ValueError, "overflow in init_nt"); PyErr_SetString(PyExc_ValueError, "overflow in init_nt");
return -1; return -1;
} }
self->nodes = calloc(self->capacity, sizeof(nodetreenode)); self->nodes = calloc(self->capacity, sizeof(nodetreenode));
if (self->nodes == NULL) { if (self->nodes == NULL) {
PyErr_NoMemory(); PyErr_NoMemory();
return -1; return -1;
} }