static int minix_rmdir(struct inode * dir, struct dentry *dentry)
{
struct inode * inode = dentry->d_inode;
int err = -ENOTEMPTY;
if (minix_empty_dir(inode)) {
err = minix_unlink(dir, dentry);
if (!err) {
dec_count(dir);
dec_count(inode);
}
}
return err;
}
static int sysv_rmdir(struct inode * dir, struct dentry * dentry)
{
struct inode *inode = dentry->d_inode;
int err = -ENOTEMPTY;
if (sysv_empty_dir(inode)) {
err = sysv_unlink(dir, dentry);
if (!err) {
inode->i_size = 0;
dec_count(inode);
dec_count(dir);
}
}
return err;
}
void kitoa(int n, char* psz)
{
int c = 0;
int ln = 0, d = 1;
if(n<0)
{
psz[c++]='-';
n = n*(-1);
}
for(ln=1;n/ln;ln*=10);
ln/=10;
while (n)
{
psz[c++] = '0' + n/ln;
if((n%=ln) == 0) {
d = dec_count(ln);
while(d--) {
psz[c++]='0';
}
break;
} else if(n<10) {
psz[c++]='0'+n;
break;
}
ln/=10;
}
if(!c) {
psz[c++]='0';
}
psz[c] = '\0';
}
static int minix_symlink(struct inode * dir, struct dentry *dentry,
const char * symname)
{
int err = -ENAMETOOLONG;
int i = strlen(symname)+1;
struct inode * inode;
if (i > dir->i_sb->s_blocksize)
goto out;
inode = minix_new_inode(dir, &err);
if (!inode)
goto out;
inode->i_mode = S_IFLNK | 0777;
minix_set_inode(inode, 0);
err = page_symlink(inode, symname, i);
if (err)
goto out_fail;
err = add_nondir(dentry, inode);
out:
return err;
out_fail:
dec_count(inode);
iput(inode);
goto out;
}
static int sysv_symlink(struct inode * dir, struct dentry * dentry,
const char * symname)
{
int err = -ENAMETOOLONG;
int l = strlen(symname)+1;
struct inode * inode;
if (l > dir->i_sb->s_blocksize)
goto out;
inode = sysv_new_inode(dir, S_IFLNK|0777);
err = PTR_ERR(inode);
if (IS_ERR(inode))
goto out;
sysv_set_inode(inode, 0);
err = block_symlink(inode, symname, l);
if (err)
goto out_fail;
mark_inode_dirty(inode);
err = add_nondir(dentry, inode);
out:
return err;
out_fail:
dec_count(inode);
iput(inode);
goto out;
}
static void dispatch_io(int rw, unsigned int num_regions,
struct dm_io_region *where, struct dpages *dp,
struct io *io, int sync)
{
int i;
struct dpages old_pages = *dp;
BUG_ON(num_regions > DM_IO_MAX_REGIONS);
if (sync)
rw |= REQ_SYNC;
/*
* For multiple regions we need to be careful to rewind
* the dp object for each call to do_region.
*/
for (i = 0; i < num_regions; i++) {
*dp = old_pages;
if (where[i].count || (rw & REQ_FLUSH))
do_region(rw, i, where + i, dp, io);
}
/*
* Drop the extra reference that we were holding to avoid
* the io being completed too early.
*/
dec_count(io, 0, 0);
}
void *rgb (void *arg)
{
arg_s *a = arg;
u64 start, finish;
unint red = a->id;
unint green = a->id + 1;
unint i;
rgb_lock(a->name, &Lock[red]);
dec_count();
rgb_lock("start", &StartLock);
rgb_unlock("start", &StartLock);
start = nsecs();
for (i = Loops; i; i--) {
#if (!DEBUG && !MUTEX && !SPIN && !TSPIN)
donothing();
#endif
rgb_lock(a->name, &Lock[green]);
rgb_unlock(a->name, &Lock[red]);
if (++red == Num_locks) red = 0;
if (++green == Num_locks) green = 0;
}
rgb_unlock(a->name, &Lock[red]);
finish = nsecs();
printf("%s %g nsecs per lock-unlock pair\n", a->name,
((double)(finish - start))/Loops);
return NULL;
}
static int add_nondir(struct dentry *dentry, struct inode *inode)
{
int err = minix_add_link(dentry, inode);
if (!err) {
d_instantiate(dentry, inode);
return 0;
}
dec_count(inode);
iput(inode);
return err;
}
FontPlatformData::~FontPlatformData()
{
dec_count();
#ifdef TRACE_FONTPLATFORMDATA_LIFE
SkDebugf("----------- ~FontPlatformData\n");
#endif
if (hashTableDeletedFontValue() != mTypeface) {
SkSafeUnref(mTypeface);
}
}
static int minix_mkdir(struct inode * dir, struct dentry *dentry, int mode)
{
struct inode * inode;
int err = -EMLINK;
if (dir->i_nlink >= minix_sb(dir->i_sb)->s_link_max)
goto out;
inc_count(dir);
inode = minix_new_inode(dir, &err);
if (!inode)
goto out_dir;
inode->i_mode = S_IFDIR | mode;
if (dir->i_mode & S_ISGID)
inode->i_mode |= S_ISGID;
minix_set_inode(inode, 0);
inc_count(inode);
err = minix_make_empty(inode, dir);
if (err)
goto out_fail;
err = minix_add_link(dentry, inode);
if (err)
goto out_fail;
d_instantiate(dentry, inode);
out:
return err;
out_fail:
dec_count(inode);
dec_count(inode);
iput(inode);
out_dir:
dec_count(dir);
goto out;
}
static int sysv_mkdir(struct inode * dir, struct dentry *dentry, int mode)
{
struct inode * inode;
int err = -EMLINK;
if (dir->i_nlink >= dir->i_sb->sv_link_max)
goto out;
inc_count(dir);
inode = sysv_new_inode(dir, S_IFDIR|mode);
err = PTR_ERR(inode);
if (IS_ERR(inode))
goto out_dir;
sysv_set_inode(inode, 0);
inc_count(inode);
err = sysv_make_empty(inode, dir);
if (err)
goto out_fail;
err = sysv_add_link(dentry, inode);
if (err)
goto out_fail;
d_instantiate(dentry, inode);
out:
return err;
out_fail:
dec_count(inode);
dec_count(inode);
iput(inode);
out_dir:
dec_count(dir);
goto out;
}
static void endio(struct bio *bio, int error)
{
struct io *io;
unsigned region;
if (error && bio_data_dir(bio) == READ)
zero_fill_bio(bio);
retrieve_io_and_region_from_bio(bio, &io, ®ion);
bio_put(bio);
dec_count(io, region, error);
}
static void endio(struct bio *bio, int error)
{
struct io *io;
unsigned region;
if (error && bio_data_dir(bio) == READ)
zero_fill_bio(bio);
/*
* The bio destructor in bio_put() may use the io object.
*/
retrieve_io_and_region_from_bio(bio, &io, ®ion);
bio_put(bio);
dec_count(io, region, error);
}
static void dispatch_io(int rw, unsigned int num_regions,
struct dm_io_region *where, struct dpages *dp,
struct io *io, int sync)
{
int i;
struct dpages old_pages = *dp;
BUG_ON(num_regions > DM_IO_MAX_REGIONS);
if (sync)
rw |= REQ_SYNC;
for (i = 0; i < num_regions; i++) {
*dp = old_pages;
if (where[i].count || (rw & REQ_FLUSH))
do_region(rw, i, where + i, dp, io);
}
dec_count(io, 0, 0);
}
static int minix_unlink(struct inode * dir, struct dentry *dentry)
{
int err = -ENOENT;
struct inode * inode = dentry->d_inode;
struct page * page;
struct minix_dir_entry * de;
de = minix_find_entry(dentry, &page);
if (!de)
goto end_unlink;
err = minix_delete_entry(de, page);
if (err)
goto end_unlink;
inode->i_ctime = dir->i_ctime;
dec_count(inode);
end_unlink:
return err;
}
static int sysv_unlink(struct inode * dir, struct dentry * dentry)
{
struct inode * inode = dentry->d_inode;
struct page * page;
struct sysv_dir_entry * de;
int err = -ENOENT;
de = sysv_find_entry(dentry, &page);
if (!de)
goto out;
err = sysv_delete_entry (de, page);
if (err)
goto out;
inode->i_ctime = dir->i_ctime;
dec_count(inode);
out:
return err;
}
/* exported free symbol that overrides loading from libc */
extern void free(void* ptr) noexcept
{
size_t size;
if (!ptr) return; /* free(nullptr) is no operation */
if ((char*)ptr >= init_heap &&
(char*)ptr <= init_heap + init_heap_use)
{
if (log_operations_init_heap) {
fprintf(stderr, PPREFIX "free(%p) on init heap\n", ptr);
}
return;
}
if (!real_free) {
fprintf(stderr, PPREFIX
"free(%p) outside init heap and without real_free !!!\n", ptr);
return;
}
ptr = (char*)ptr - alignment;
if (*(size_t*)((char*)ptr + alignment - sizeof(size_t)) != sentinel) {
fprintf(stderr, PPREFIX
"free(%p) has no sentinel !!! memory corruption?\n", ptr);
}
size = *(size_t*)ptr;
dec_count(size);
if (log_operations && size >= log_operations_threshold) {
fprintf(stderr, PPREFIX "free(%p) -> %'lld (current %'lld)\n",
ptr, (long long)size, curr);
}
(*real_free)(ptr);
}
/* exported free symbol that overrides loading from libc */
extern void free(void* ptr)
{
size_t size;
if (!ptr) return; /* free(NULL) is no operation */
if ((char*)ptr >= init_heap &&
(char*)ptr <= init_heap + init_heap_use)
{
if (log_operations_init_heap) {
fprintf(stderr, "malloc_count ### free(%p) on init heap\n", ptr);
}
return;
}
if (!real_free) {
fprintf(stderr, "malloc_count ### free(%p) outside init heap and without real_free !!!\n", ptr);
return;
}
ptr = (char*)ptr - 2 * sizeof(size_t);
if (((size_t*)ptr)[1] != sentinel) {
fprintf(stderr, "malloc_count ### free(%p) has no sentinel !!! memory corruption?\n", ptr);
}
size = ((size_t*)ptr)[0];
dec_count(size);
if (log_operations && size >= log_operations_threshold) {
fprintf(stderr, "malloc_count ### free(%p) -> %'lld (current %'lld)\n",
ptr, (long long)size, curr);
}
(*real_free)(ptr);
}
/* exported realloc() symbol that overrides loading from libc */
extern void * realloc(void* ptr, size_t size)
{
void* newptr;
size_t oldsize;
if ((char*)ptr >= (char*)init_heap &&
(char*)ptr <= (char*)init_heap + init_heap_use)
{
if (log_operations_init_heap) {
fprintf(stderr, "malloc_count ### realloc(%p) = on init heap\n", ptr);
}
ptr = (char*)ptr - 2 * sizeof(size_t);
if (((size_t*)ptr)[1] != sentinel) {
fprintf(stderr, "malloc_count ### realloc(%p) has no sentinel !!! memory corruption?\n", ptr);
}
oldsize = ((size_t*)ptr)[0];
if (oldsize >= size) {
/* keep old area, just reduce the size */
((size_t*)ptr)[0] = size;
return (char*)ptr + 2 * sizeof(size_t);
}
else {
/* allocate new area and copy data */
ptr = (char*)ptr + 2 * sizeof(size_t);
newptr = malloc(size);
memcpy(newptr, ptr, oldsize);
free(ptr);
return newptr;
}
}
if (size == 0) { /* special case size == 0 -> free() */
free(ptr);
return NULL;
}
if (ptr == NULL) { /* special case ptr == 0 -> malloc() */
return malloc(size);
}
ptr = (char*)ptr - 2 * sizeof(size_t);
if (((size_t*)ptr)[1] != sentinel) {
fprintf(stderr, "malloc_count ### free(%p) has no sentinel !!! memory corruption?\n", ptr);
}
oldsize = ((size_t*)ptr)[0];
dec_count(oldsize);
inc_count(size);
newptr = (*real_realloc)(ptr, 2 * sizeof(size_t) + size);
if (log_operations && size >= log_operations_threshold)
{
if (newptr == ptr)
fprintf(stderr, "malloc_count ### realloc(%'lld -> %'lld) = %p (current %'lld)\n",
(long long)oldsize, (long long)size, newptr, curr);
else
fprintf(stderr, "malloc_count ### realloc(%'lld -> %'lld) = %p -> %p (current %'lld)\n",
(long long)oldsize, (long long)size, ptr, newptr, curr);
}
((size_t*)newptr)[0] = size;
return (char*)newptr + 2 * sizeof(size_t);
}
static int minix_rename(struct inode * old_dir, struct dentry *old_dentry,
struct inode * new_dir, struct dentry *new_dentry)
{
struct minix_sb_info * info = minix_sb(old_dir->i_sb);
struct inode * old_inode = old_dentry->d_inode;
struct inode * new_inode = new_dentry->d_inode;
struct page * dir_page = NULL;
struct minix_dir_entry * dir_de = NULL;
struct page * old_page;
struct minix_dir_entry * old_de;
int err = -ENOENT;
old_de = minix_find_entry(old_dentry, &old_page);
if (!old_de)
goto out;
if (S_ISDIR(old_inode->i_mode)) {
err = -EIO;
dir_de = minix_dotdot(old_inode, &dir_page);
if (!dir_de)
goto out_old;
}
if (new_inode) {
struct page * new_page;
struct minix_dir_entry * new_de;
err = -ENOTEMPTY;
if (dir_de && !minix_empty_dir(new_inode))
goto out_dir;
err = -ENOENT;
new_de = minix_find_entry(new_dentry, &new_page);
if (!new_de)
goto out_dir;
inc_count(old_inode);
minix_set_link(new_de, new_page, old_inode);
new_inode->i_ctime = CURRENT_TIME_SEC;
if (dir_de)
new_inode->i_nlink--;
dec_count(new_inode);
} else {
if (dir_de) {
err = -EMLINK;
if (new_dir->i_nlink >= info->s_link_max)
goto out_dir;
}
inc_count(old_inode);
err = minix_add_link(new_dentry, old_inode);
if (err) {
dec_count(old_inode);
goto out_dir;
}
if (dir_de)
inc_count(new_dir);
}
minix_delete_entry(old_de, old_page);
dec_count(old_inode);
if (dir_de) {
minix_set_link(dir_de, dir_page, new_dir);
dec_count(old_dir);
}
return 0;
out_dir:
if (dir_de) {
kunmap(dir_page);
page_cache_release(dir_page);
}
out_old:
kunmap(old_page);
page_cache_release(old_page);
out:
return err;
}
/*-----------------------------------------------------------------
* IO routines that accept a list of pages.
*---------------------------------------------------------------*/
static void do_region(int rw, unsigned region, struct dm_io_region *where,
struct dpages *dp, struct io *io)
{
struct bio *bio;
struct page *page;
unsigned long len;
unsigned offset;
unsigned num_bvecs;
sector_t remaining = where->count;
struct request_queue *q = bdev_get_queue(where->bdev);
unsigned short logical_block_size = queue_logical_block_size(q);
sector_t num_sectors;
unsigned int uninitialized_var(special_cmd_max_sectors);
/*
* Reject unsupported discard and write same requests.
*/
if (rw & REQ_DISCARD)
special_cmd_max_sectors = q->limits.max_discard_sectors;
else if (rw & REQ_WRITE_SAME)
special_cmd_max_sectors = q->limits.max_write_same_sectors;
if ((rw & (REQ_DISCARD | REQ_WRITE_SAME)) && special_cmd_max_sectors == 0) {
dec_count(io, region, -EOPNOTSUPP);
return;
}
/*
* where->count may be zero if rw holds a flush and we need to
* send a zero-sized flush.
*/
do {
/*
* Allocate a suitably sized-bio.
*/
if ((rw & REQ_DISCARD) || (rw & REQ_WRITE_SAME))
num_bvecs = 1;
else
num_bvecs = min_t(int, BIO_MAX_PAGES,
dm_sector_div_up(remaining, (PAGE_SIZE >> SECTOR_SHIFT)));
bio = bio_alloc_bioset(GFP_NOIO, num_bvecs, io->client->bios);
bio->bi_iter.bi_sector = where->sector + (where->count - remaining);
bio->bi_bdev = where->bdev;
bio->bi_end_io = endio;
store_io_and_region_in_bio(bio, io, region);
if (rw & REQ_DISCARD) {
num_sectors = min_t(sector_t, special_cmd_max_sectors, remaining);
bio->bi_iter.bi_size = num_sectors << SECTOR_SHIFT;
remaining -= num_sectors;
} else if (rw & REQ_WRITE_SAME) {
/*
* WRITE SAME only uses a single page.
*/
dp->get_page(dp, &page, &len, &offset);
bio_add_page(bio, page, logical_block_size, offset);
num_sectors = min_t(sector_t, special_cmd_max_sectors, remaining);
bio->bi_iter.bi_size = num_sectors << SECTOR_SHIFT;
offset = 0;
remaining -= num_sectors;
dp->next_page(dp);
} else while (remaining) {
/*
* Try and add as many pages as possible.
*/
dp->get_page(dp, &page, &len, &offset);
len = min(len, to_bytes(remaining));
if (!bio_add_page(bio, page, len, offset))
break;
offset = 0;
remaining -= to_sector(len);
dp->next_page(dp);
}
atomic_inc(&io->count);
submit_bio(rw, bio);
} while (remaining);
}
/* exported realloc() symbol that overrides loading from libc */
extern void * realloc(void* ptr, size_t size) noexcept
{
void* newptr;
size_t oldsize;
if ((char*)ptr >= (char*)init_heap &&
(char*)ptr <= (char*)init_heap + init_heap_use)
{
if (log_operations_init_heap) {
fprintf(stderr, PPREFIX "realloc(%p) = on init heap\n", ptr);
}
ptr = (char*)ptr - alignment;
if (*(size_t*)((char*)ptr + alignment - sizeof(size_t)) != sentinel) {
fprintf(stderr, PPREFIX
"realloc(%p) has no sentinel !!! memory corruption?\n",
ptr);
}
oldsize = *(size_t*)ptr;
if (oldsize >= size) {
/* keep old area, just reduce the size */
*(size_t*)ptr = size;
return (char*)ptr + alignment;
}
else {
/* allocate new area and copy data */
ptr = (char*)ptr + alignment;
newptr = malloc(size);
memcpy(newptr, ptr, oldsize);
free(ptr);
return newptr;
}
}
if (size == 0) { /* special case size == 0 -> free() */
free(ptr);
return nullptr;
}
if (ptr == nullptr) { /* special case ptr == 0 -> malloc() */
return malloc(size);
}
ptr = (char*)ptr - alignment;
if (*(size_t*)((char*)ptr + alignment - sizeof(size_t)) != sentinel) {
fprintf(stderr, PPREFIX
"free(%p) has no sentinel !!! memory corruption?\n", ptr);
}
oldsize = *(size_t*)ptr;
dec_count(oldsize);
inc_count(size);
newptr = (*real_realloc)(ptr, alignment + size);
if (log_operations && size >= log_operations_threshold)
{
if (newptr == ptr)
fprintf(stderr, PPREFIX
"realloc(%'lld -> %'lld) = %p (current %'lld)\n",
(long long)oldsize, (long long)size, newptr, curr);
else
fprintf(stderr, PPREFIX
"realloc(%'lld -> %'lld) = %p -> %p (current %'lld)\n",
(long long)oldsize, (long long)size, ptr, newptr, curr);
}
*(size_t*)newptr = size;
return (char*)newptr + alignment;
}
