struct iovec *iov_copy;
int count = 0;
- OBD_ALLOC(iov_copy, sizeof(*iov_copy) * iter->nr_segs);
+ OBD_ALLOC_PTR_ARRAY(iov_copy, iter->nr_segs);
if (!iov_copy)
return -ENOMEM;
bytes = __generic_file_aio_write(iocb, iov_copy, count,
&iocb->ki_pos);
- OBD_FREE(iov_copy, sizeof(*iov_copy) * iter->nr_segs);
+ OBD_FREE_PTR_ARRAY(iov_copy, iter->nr_segs);
if (bytes > 0)
iov_iter_advance(iter, bytes);
else
stripes = lmv->lmv_stripe_count;
- OBD_ALLOC_LARGE(lslr, sizeof(*lslr) * stripes);
+ OBD_ALLOC_PTR_ARRAY_LARGE(lslr, stripes);
if (lslr == NULL) {
OBD_FREE_PTR(llmv);
LASSERT(llmv->ll_lslr != NULL);
- OBD_FREE_LARGE(llmv->ll_lslr,
- sizeof(*llmv->ll_lslr) *
- llmv->ll_stripes_allocated);
+ OBD_FREE_PTR_ARRAY_LARGE(llmv->ll_lslr,
+ llmv->ll_stripes_allocated);
OBD_FREE_PTR(llu);
} else {
if (llmv->ll_lslr != NULL)
- OBD_FREE_LARGE(llmv->ll_lslr,
- sizeof(*llmv->ll_lslr) *
+ OBD_FREE_PTR_ARRAY_LARGE(
+ llmv->ll_lslr,
llmv->ll_stripes_allocated);
OBD_FREE_PTR(llmv);
int new_stripes = index + 1;
size_t old_size = sizeof(*lslr) * llmv->ll_stripes_allocated;
- OBD_ALLOC_LARGE(new_lslr, sizeof(*new_lslr) * new_stripes);
+ OBD_ALLOC_PTR_ARRAY_LARGE(new_lslr, new_stripes);
if (new_lslr == NULL) {
llmv->ll_failed = 1;
else
count = lmv4->lmv_stripe_count;
- OBD_ALLOC_LARGE(lslr, sizeof(*lslr) * count);
+ OBD_ALLOC_PTR_ARRAY_LARGE(lslr, count);
if (lslr == NULL) {
OBD_FREE_PTR(llu);
OBD_ALLOC(lfa, size);
if (!lfa)
RETURN(-ENOMEM);
- OBD_ALLOC(rcs, sizeof(int) * nr);
+ OBD_ALLOC_PTR_ARRAY(rcs, nr);
if (!rcs)
GOTO(free_lfa, rc = -ENOMEM);
}
free_rcs:
- OBD_FREE(rcs, sizeof(int) * nr);
+ OBD_FREE_PTR_ARRAY(rcs, nr);
free_lfa:
OBD_FREE(lfa, size);
#if defined(HAVE_DIO_ITER)
kvfree(pages);
#else
- OBD_FREE_LARGE(pages, npages * sizeof(*pages));
+ OBD_FREE_PTR_ARRAY_LARGE(pages, npages);
#endif
}
size = min_t(size_t, maxsize, iter->iov->iov_len);
page_count = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
- OBD_ALLOC_LARGE(*pages, page_count * sizeof(**pages));
+ OBD_ALLOC_PTR_ARRAY_LARGE(*pages, page_count);
if (*pages == NULL)
return -ENOMEM;
}
/* split FIDs by targets */
- OBD_ALLOC(fas, sizeof(fas) * tgt_count);
+ OBD_ALLOC_PTR_ARRAY(fas, tgt_count);
if (fas == NULL)
GOTO(out, rc = -ENOMEM);
- OBD_ALLOC(rcs, sizeof(int *) * tgt_count);
+ OBD_ALLOC_PTR_ARRAY(rcs, tgt_count);
if (rcs == NULL)
GOTO(out_fas, rc = -ENOMEM);
if (!fas[idx])
GOTO(out, rc = -ENOMEM);
if (!rcs[idx])
- OBD_ALLOC(rcs[idx], sizeof(int) * fa->fa_nr);
+ OBD_ALLOC_PTR_ARRAY(rcs[idx], fa->fa_nr);
if (!rcs[idx])
GOTO(out, rc = -ENOMEM);
OBD_FREE(fas[i], offsetof(struct fid_array,
fa_fids[fa->fa_nr]));
if (rcs && rcs[i])
- OBD_FREE(rcs[i], sizeof(int) * fa->fa_nr);
+ OBD_FREE_PTR_ARRAY(rcs[i], fa->fa_nr);
}
if (rcs)
- OBD_FREE(rcs, sizeof(int *) * tgt_count);
+ OBD_FREE_PTR_ARRAY(rcs, tgt_count);
out_fas:
if (fas)
- OBD_FREE(fas, sizeof(fas) * tgt_count);
+ OBD_FREE_PTR_ARRAY(fas, tgt_count);
RETURN(rc);
}
fid = &op_data->op_fid1;
LASSERT(inode != NULL);
- OBD_ALLOC(page_pool, sizeof(page_pool[0]) * max_pages);
+ OBD_ALLOC_PTR_ARRAY(page_pool, max_pages);
if (page_pool != NULL) {
page_pool[0] = page0;
} else {
}
if (page_pool != &page0)
- OBD_FREE(page_pool, sizeof(page_pool[0]) * max_pages);
+ OBD_FREE_PTR_ARRAY(page_pool, max_pages);
RETURN(rc);
}
if (cld_is_nodemap(cld) && (mgc_conn->c_peer.nid == LNET_NID_LO_0))
GOTO(out, rc = 0);
- /* allocate buffer for bulk transfer.
- * if this is the first time for this mgs to read logs,
- * CONFIG_READ_NRPAGES_INIT will be used since it will read all logs
- * once; otherwise, it only reads increment of logs, this should be
- * small and CONFIG_READ_NRPAGES will be used.
- */
- nrpages = CONFIG_READ_NRPAGES;
+ /* allocate buffer for bulk transfer.
+ * if this is the first time for this mgs to read logs,
+ * CONFIG_READ_NRPAGES_INIT will be used since it will read all logs
+ * once; otherwise, it only reads increment of logs, this should be
+ * small and CONFIG_READ_NRPAGES will be used.
+ */
+ nrpages = CONFIG_READ_NRPAGES;
if (cfg->cfg_last_idx == 0 || cld_is_nodemap(cld))
- nrpages = CONFIG_READ_NRPAGES_INIT;
+ nrpages = CONFIG_READ_NRPAGES_INIT;
- OBD_ALLOC(pages, sizeof(*pages) * nrpages);
- if (pages == NULL)
- GOTO(out, rc = -ENOMEM);
+ OBD_ALLOC_PTR_ARRAY(pages, nrpages);
+ if (pages == NULL)
+ GOTO(out, rc = -ENOMEM);
- for (i = 0; i < nrpages; i++) {
+ for (i = 0; i < nrpages; i++) {
pages[i] = alloc_page(GFP_KERNEL);
- if (pages[i] == NULL)
- GOTO(out, rc = -ENOMEM);
- }
+ if (pages[i] == NULL)
+ GOTO(out, rc = -ENOMEM);
+ }
again:
#ifdef HAVE_SERVER_SUPPORT
break;
__free_page(pages[i]);
}
- OBD_FREE(pages, sizeof(*pages) * nrpages);
+ OBD_FREE_PTR_ARRAY(pages, nrpages);
}
return rc;
}
CDEBUG(D_MGS, "Reading IR log %s bufsize %ld.\n",
body->mcb_name, bufsize);
- OBD_ALLOC(pages, sizeof(*pages) * nrpages);
+ OBD_ALLOC_PTR_ARRAY(pages, nrpages);
if (!pages)
GOTO(out, rc = -ENOMEM);
__free_page(pages[i]);
}
- OBD_FREE(pages, sizeof(*pages) * nrpages);
+ OBD_FREE_PTR_ARRAY(pages, nrpages);
}
if (fsdb)
if (rw == OBD_BRW_WRITE)
brw_flags = OBD_BRW_ASYNC;
- OBD_ALLOC(pga, npages * sizeof(*pga));
+ OBD_ALLOC_PTR_ARRAY(pga, npages);
if (!pga)
RETURN(-ENOMEM);
- OBD_ALLOC(pages, npages * sizeof(*pages));
+ OBD_ALLOC_PTR_ARRAY(pages, npages);
if (!pages) {
- OBD_FREE(pga, npages * sizeof(*pga));
+ OBD_FREE_PTR_ARRAY(pga, npages);
RETURN(-ENOMEM);
}
}
__free_page(pgp->pg);
}
- OBD_FREE(pga, npages * sizeof(*pga));
- OBD_FREE(pages, npages * sizeof(*pages));
+ OBD_FREE_PTR_ARRAY(pga, npages);
+ OBD_FREE_PTR_ARRAY(pages, npages);
RETURN(rc);
}
apc = npages = batch >> PAGE_SHIFT;
tot_pages = count >> PAGE_SHIFT;
- OBD_ALLOC_LARGE(lnb, apc * sizeof(*lnb));
+ OBD_ALLOC_PTR_ARRAY_LARGE(lnb, apc);
if (!lnb)
RETURN(-ENOMEM);
}
out:
- OBD_FREE_LARGE(lnb, apc * sizeof(*lnb));
+ OBD_FREE_PTR_ARRAY_LARGE(lnb, apc);
RETURN(ret);
}
RETURN(rc = -ENOSPC);
}
- OBD_ALLOC(batch, nr_saved * sizeof(*batch));
+ OBD_ALLOC_PTR_ARRAY(batch, nr_saved);
if (batch == NULL)
RETURN(-ENOMEM);
continue;
ofd_object_put(env, fo);
}
- OBD_FREE(batch, nr_saved * sizeof(*batch));
+ OBD_FREE_PTR_ARRAY(batch, nr_saved);
CDEBUG((objects == 0 && rc == 0) ? D_ERROR : D_OTHER,
"created %d/%d objects: %d\n", objects, nr_saved, rc);
static void osc_release_ppga(struct brw_page **ppga, size_t count)
{
- LASSERT(ppga != NULL);
- OBD_FREE(ppga, sizeof(*ppga) * count);
+ LASSERT(ppga != NULL);
+ OBD_FREE_PTR_ARRAY(ppga, count);
}
static int brw_interpret(const struct lu_env *env,
if (mem_tight)
mpflag = cfs_memory_pressure_get_and_set();
- OBD_ALLOC(pga, sizeof(*pga) * page_count);
+ OBD_ALLOC_PTR_ARRAY(pga, page_count);
if (pga == NULL)
GOTO(out, rc = -ENOMEM);
if (oa)
OBD_SLAB_FREE_PTR(oa, osc_obdo_kmem);
if (pga)
- OBD_FREE(pga, sizeof(*pga) * page_count);
+ OBD_FREE_PTR_ARRAY(pga, page_count);
/* this should happen rarely and is pretty bad, it makes the
* pending list not follow the dirty order */
while (!list_empty(ext_list)) {
__free_page(pages[i]);
}
}
- OBD_FREE(pages, npages * sizeof(*pages));
+ OBD_FREE_PTR_ARRAY(pages, npages);
}
OBD_FREE_PTR(it);
}
npages = min_t(unsigned int, OFD_MAX_BRW_SIZE, 1 << 20);
npages /= PAGE_SIZE;
- OBD_ALLOC(pages, npages * sizeof(*pages));
+ OBD_ALLOC_PTR_ARRAY(pages, npages);
if (pages == NULL)
RETURN(-ENOMEM);
if (pages[i] != NULL)
__free_page(pages[i]);
}
- OBD_FREE(pages, it->ooi_total_npages * sizeof(*pages));
+ OBD_FREE_PTR_ARRAY(pages, it->ooi_total_npages);
it->ooi_pos_page = 0;
it->ooi_total_npages = 0;
list_for_each(le, &list)
count++;
if (count > 2)
- OBD_ALLOC_LARGE(arr, sizeof(int) * count);
+ OBD_ALLOC_PTR_ARRAY_LARGE(arr, count);
else
arr = NULL;
i = 0;
PFID(&lgid.lgl_oi.oi_fid), i);
}
if (arr)
- OBD_FREE_LARGE(arr, sizeof(int) * count);
+ OBD_FREE_PTR_ARRAY_LARGE(arr, count);
llog_ctxt_put(ctxt);
array->q_locks[i] = NULL;
}
array->q_cnt = 0;
- OBD_FREE(array->q_locks, array->q_max * sizeof(*array->q_locks));
+ OBD_FREE_PTR_ARRAY(array->q_locks, array->q_max);
array->q_locks = NULL;
array->q_max = 0;
}
array->q_max = count + count / 2 + 10;
count = 0;
LASSERT(array->q_locks == NULL && array->q_cnt == 0);
- OBD_ALLOC(array->q_locks,
- sizeof(*array->q_locks) * array->q_max);
+ OBD_ALLOC_PTR_ARRAY(array->q_locks, array->q_max);
if (array->q_locks == NULL) {
array->q_max = 0;
RETURN(-ENOMEM);
npages /= PAGE_SIZE;
/* allocate pages for bulk index read */
- OBD_ALLOC(pages, npages * sizeof(*pages));
+ OBD_ALLOC_PTR_ARRAY(pages, npages);
if (pages == NULL)
GOTO(out, rc = -ENOMEM);
for (i = 0; i < npages; i++) {
for (i = 0; i < npages; i++)
if (pages[i] != NULL)
__free_page(pages[i]);
- OBD_FREE(pages, npages * sizeof(*pages));
+ OBD_FREE_PTR_ARRAY(pages, npages);
}
/* Update index version */