type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
defines | #define LCM_COMPILE_ASSERT_XX(condition, line) char assertion_failed_at_line_##line[(condition)?1:-1] |
includes |
#include <linux/fs.h> |
includes | #include <linux/types.h> |
includes | #include <linux/highmem.h> |
includes | #include <linux/bitops.h> |
includes | #include <linux/list.h> |
includes | #include <cluster/masklog.h> |
includes | #include <cluster/masklog.h> |
defines | #define MLOG_MASK_PREFIX ML_RESERVATIONS |
defines | #define OCFS2_CHECK_RESERVATIONS |
defines |
#define OCFS2_MIN_RESV_WINDOW_BITS 8 |
defines | #define OCFS2_MAX_RESV_WINDOW_BITS 1024 |
functions | int ocfs2_dir_resv_allowed(struct ocfs2_super *osb)
{
return (osb->osb_resv_level && osb->osb_dir_resv_level);
} |
functions | int ocfs2_resv_window_bits(struct ocfs2_reservation_map *resmap,
struct ocfs2_alloc_reservation *resv)
{
struct ocfs2_super *osb = resmap->m_osb;
unsigned int bits;
if (!(resv->r_flags & OCFS2_RESV_FLAG_DIR)) {
/* 8, 16, 32, 64, 128, 256, 512, 1024 */
bits = 4 << osb->osb_resv_level;
} |
functions | int ocfs2_resv_end(struct ocfs2_alloc_reservation *resv)
{
if (resv->r_len)
return resv->r_start + resv->r_len - 1;
return resv->r_start;
} |
functions | int ocfs2_resv_empty(struct ocfs2_alloc_reservation *resv)
{
return !!(resv->r_len == 0);
} |
functions | int ocfs2_resmap_disabled(struct ocfs2_reservation_map *resmap)
{
if (resmap->m_osb->osb_resv_level == 0)
return 1;
return 0;
} |
functions | void ocfs2_dump_resv(struct ocfs2_reservation_map *resmap)
{
struct ocfs2_super *osb = resmap->m_osb;
struct rb_node *node;
struct ocfs2_alloc_reservation *resv;
int i = 0;
mlog(ML_NOTICE, "Dumping resmap for device %s. Bitmap length: %u\n",
osb->dev_str, resmap->m_bitmap_len);
node = rb_first(&resmap->m_... |
functions | int ocfs2_validate_resmap_bits(struct ocfs2_reservation_map *resmap,
int i,
struct ocfs2_alloc_reservation *resv)
{
char *disk_bitmap = resmap->m_disk_bitmap;
unsigned int start = resv->r_start;
unsigned int end = ocfs2_resv_end(resv);
while (start <= end) {
if (ocfs2_test_bit(start, disk_bit... |
functions | void ocfs2_check_resmap(struct ocfs2_reservation_map *resmap)
{
unsigned int off = 0;
int i = 0;
struct rb_node *node;
struct ocfs2_alloc_reservation *resv;
node = rb_first(&resmap->m_reservations);
while (node) {
resv = rb_entry(node, struct ocfs2_alloc_reservation, r_node);
if (i > 0 && resv->r_start <= o... |
functions | void ocfs2_check_resmap(struct ocfs2_reservation_map *resmap)
{
} |
functions | void ocfs2_resv_init_once(struct ocfs2_alloc_reservation *resv)
{
memset(resv, 0, sizeof(*resv));
INIT_LIST_HEAD(&resv->r_lru);
} |
functions | void ocfs2_resv_set_type(struct ocfs2_alloc_reservation *resv,
unsigned int flags)
{
BUG_ON(flags & ~OCFS2_RESV_TYPES);
resv->r_flags |= flags;
} |
functions | int ocfs2_resmap_init(struct ocfs2_super *osb,
struct ocfs2_reservation_map *resmap)
{
memset(resmap, 0, sizeof(*resmap));
resmap->m_osb = osb;
resmap->m_reservations = RB_ROOT;
/* m_bitmap_len is initialized to zero by the above memset. */
INIT_LIST_HEAD(&resmap->m_lru);
return 0;
} |
functions | void ocfs2_resv_mark_lru(struct ocfs2_reservation_map *resmap,
struct ocfs2_alloc_reservation *resv)
{
assert_spin_locked(&resv_lock);
if (!list_empty(&resv->r_lru))
list_del_init(&resv->r_lru);
list_add_tail(&resv->r_lru, &resmap->m_lru);
} |
functions | void __ocfs2_resv_trunc(struct ocfs2_alloc_reservation *resv)
{
resv->r_len = 0;
resv->r_start = 0;
} |
functions | void ocfs2_resv_remove(struct ocfs2_reservation_map *resmap,
struct ocfs2_alloc_reservation *resv)
{
if (resv->r_flags & OCFS2_RESV_FLAG_INUSE) {
list_del_init(&resv->r_lru);
rb_erase(&resv->r_node, &resmap->m_reservations);
resv->r_flags &= ~OCFS2_RESV_FLAG_INUSE;
} |
functions | void __ocfs2_resv_discard(struct ocfs2_reservation_map *resmap,
struct ocfs2_alloc_reservation *resv)
{
assert_spin_locked(&resv_lock);
__ocfs2_resv_trunc(resv);
/*
* last_len and last_start no longer make sense if
* we're changing the range of our allocations.
*/
resv->r_last_len = resv->r_last_start =... |
functions | void ocfs2_resv_discard(struct ocfs2_reservation_map *resmap,
struct ocfs2_alloc_reservation *resv)
{
if (resv) {
spin_lock(&resv_lock);
__ocfs2_resv_discard(resmap, resv);
spin_unlock(&resv_lock);
} |
functions | void ocfs2_resmap_clear_all_resv(struct ocfs2_reservation_map *resmap)
{
struct rb_node *node;
struct ocfs2_alloc_reservation *resv;
assert_spin_locked(&resv_lock);
while ((node = rb_last(&resmap->m_reservations)) != NULL) {
resv = rb_entry(node, struct ocfs2_alloc_reservation, r_node);
__ocfs2_resv_discard(... |
functions | void ocfs2_resmap_restart(struct ocfs2_reservation_map *resmap,
unsigned int clen, char *disk_bitmap)
{
if (ocfs2_resmap_disabled(resmap))
return;
spin_lock(&resv_lock);
ocfs2_resmap_clear_all_resv(resmap);
resmap->m_bitmap_len = clen;
resmap->m_disk_bitmap = disk_bitmap;
spin_unlock(&resv_lock);
} |
functions | void ocfs2_resmap_uninit(struct ocfs2_reservation_map *resmap)
{
/* Does nothing for now. Keep this around for API symmetry */
} |
functions | void ocfs2_resv_insert(struct ocfs2_reservation_map *resmap,
struct ocfs2_alloc_reservation *new)
{
struct rb_root *root = &resmap->m_reservations;
struct rb_node *parent = NULL;
struct rb_node **p = &root->rb_node;
struct ocfs2_alloc_reservation *tmp;
assert_spin_locked(&resv_lock);
<<<<<<< HEAD
trace... |
functions | int ocfs2_resmap_find_free_bits(struct ocfs2_reservation_map *resmap,
unsigned int wanted,
unsigned int search_start,
unsigned int search_len,
unsigned int *rstart,
unsigned int *rlen)
{
void *bitmap = resmap->m_disk_bitmap;
unsigned int best_start, best_len = 0;... |
functions | void __ocfs2_resv_find_window(struct ocfs2_reservation_map *resmap,
struct ocfs2_alloc_reservation *resv,
unsigned int goal, unsigned int wanted)
{
struct rb_root *root = &resmap->m_reservations;
unsigned int gap_start, gap_end, gap_len;
struct ocfs2_alloc_reservation *prev_resv, *next_resv;
struc... |
functions | else if (clen > best_len) {
best_len = clen;
best_start = cstart;
} |
functions | void ocfs2_cannibalize_resv(struct ocfs2_reservation_map *resmap,
struct ocfs2_alloc_reservation *resv,
unsigned int wanted)
{
struct ocfs2_alloc_reservation *lru_resv;
int tmpwindow = !!(resv->r_flags & OCFS2_RESV_FLAG_TMP);
unsigned int min_bits;
if (!tmpwindow)
min_bits = ocfs2_resv_window_bits(... |
functions | void ocfs2_resv_find_window(struct ocfs2_reservation_map *resmap,
struct ocfs2_alloc_reservation *resv,
unsigned int wanted)
{
unsigned int goal = 0;
BUG_ON(!ocfs2_resv_empty(resv));
/*
* Begin by trying to get a window as close to the previous
* one as possible. Using the most recent allocation ... |
functions | int ocfs2_resmap_resv_bits(struct ocfs2_reservation_map *resmap,
struct ocfs2_alloc_reservation *resv,
int *cstart, int *clen)
{
<<<<<<< HEAD
=======
unsigned int wanted = *clen;
>>>>>>> 296c66da8a02d52243f45b80521febece5ed498a
if (resv == NULL || ocfs2_resmap_disabled(resmap))
return -ENOSPC;
spin_l... |
functions | void
ocfs2_adjust_resv_from_alloc(struct ocfs2_reservation_map *resmap,
struct ocfs2_alloc_reservation *resv,
unsigned int start, unsigned int end)
{
unsigned int rhs = 0;
unsigned int old_end = ocfs2_resv_end(resv);
BUG_ON(start != resv->r_start || old_end < end);
/*
* Completely used? We ca... |
functions | void ocfs2_resmap_claimed_bits(struct ocfs2_reservation_map *resmap,
struct ocfs2_alloc_reservation *resv,
u32 cstart, u32 clen)
{
unsigned int cend = cstart + clen - 1;
if (resmap == NULL || ocfs2_resmap_disabled(resmap))
return;
if (resv == NULL)
return;
BUG_ON(cstart != resv->r_start);... |
includes |
#include <linux/init.h> |
includes | #include <linux/module.h> |
includes | #include <linux/mm.h> |
includes | #include <linux/device.h> |
includes | #include <linux/dmaengine.h> |
includes | #include <linux/hardirq.h> |
includes | #include <linux/spinlock.h> |
includes | #include <linux/percpu.h> |
includes | #include <linux/rcupdate.h> |
includes | #include <linux/mutex.h> |
includes | #include <linux/jiffies.h> |
includes | #include <linux/rculist.h> |
includes | #include <linux/idr.h> |
includes | #include <linux/slab.h> |
defines |
#define dma_device_satisfies_mask(device, mask) \ |
structs | struct dma_chan_tbl_ent {
struct dma_chan *chan;
}; |
functions | ssize_t show_memcpy_count(struct device *dev, struct device_attribute *attr, char *buf)
{
struct dma_chan *chan;
unsigned long count = 0;
int i;
int err;
mutex_lock(&dma_list_mutex);
chan = dev_to_dma_chan(dev);
if (chan) {
for_each_possible_cpu(i)
count += per_cpu_ptr(chan->local, i)->memcpy_count;
err ... |
functions | ssize_t show_bytes_transferred(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct dma_chan *chan;
unsigned long count = 0;
int i;
int err;
mutex_lock(&dma_list_mutex);
chan = dev_to_dma_chan(dev);
if (chan) {
for_each_possible_cpu(i)
count += per_cpu_ptr(chan->local, i)->bytes... |
functions | ssize_t show_in_use(struct device *dev, struct device_attribute *attr, char *buf)
{
struct dma_chan *chan;
int err;
mutex_lock(&dma_list_mutex);
chan = dev_to_dma_chan(dev);
if (chan)
err = sprintf(buf, "%d\n", chan->client_count);
else
err = -ENODEV;
mutex_unlock(&dma_list_mutex);
return err;
} |
functions | void chan_dev_release(struct device *dev)
{
struct dma_chan_dev *chan_dev;
chan_dev = container_of(dev, typeof(*chan_dev), device);
if (atomic_dec_and_test(chan_dev->idr_ref)) {
mutex_lock(&dma_list_mutex);
idr_remove(&dma_idr, chan_dev->dev_id);
mutex_unlock(&dma_list_mutex);
kfree(chan_dev->idr_ref);
} |
functions | int
__dma_device_satisfies_mask(struct dma_device *device, dma_cap_mask_t *want)
{
dma_cap_mask_t has;
bitmap_and(has.bits, want->bits, device->cap_mask.bits,
DMA_TX_TYPE_END);
return bitmap_equal(want->bits, has.bits, DMA_TX_TYPE_END);
} |
functions | void balance_ref_count(struct dma_chan *chan)
{
struct module *owner = dma_chan_to_owner(chan);
while (chan->client_count < dmaengine_ref_count) {
__module_get(owner);
chan->client_count++;
} |
functions | int dma_chan_get(struct dma_chan *chan)
{
int err = -ENODEV;
struct module *owner = dma_chan_to_owner(chan);
if (chan->client_count) {
__module_get(owner);
err = 0;
} |
functions | void dma_chan_put(struct dma_chan *chan)
{
if (!chan->client_count)
return; /* this channel failed alloc_chan_resources */
chan->client_count--;
module_put(dma_chan_to_owner(chan));
if (chan->client_count == 0)
chan->device->device_free_chan_resources(chan);
} |
functions | dma_status dma_sync_wait(struct dma_chan *chan, dma_cookie_t cookie)
{
enum dma_status status;
unsigned long dma_sync_wait_timeout = jiffies + msecs_to_jiffies(5000);
dma_async_issue_pending(chan);
do {
status = dma_async_is_tx_complete(chan, cookie, NULL, NULL);
if (time_after_eq(jiffies, dma_sync_wait_timeou... |
functions | __init dma_channel_table_init(void)
{
enum dma_transaction_type cap;
int err = 0;
bitmap_fill(dma_cap_mask_all.bits, DMA_TX_TYPE_END);
/* 'interrupt', 'private', and 'slave' are channel capabilities,
* but are not associated with an operation so they do not need
* an entry in the channel_table
*/
clear_bit... |
functions | void dma_issue_pending_all(void)
{
struct dma_device *device;
struct dma_chan *chan;
rcu_read_lock();
list_for_each_entry_rcu(device, &dma_device_list, global_node) {
if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
continue;
list_for_each_entry(chan, &device->channels, device_node)
if (chan->client_count... |
functions | void dma_channel_rebalance(void)
{
struct dma_chan *chan;
struct dma_device *device;
int cpu;
int cap;
int n;
/* undo the last distribution */
for_each_dma_cap_mask(cap, dma_cap_mask_all)
for_each_possible_cpu(cpu)
per_cpu_ptr(channel_table[cap], cpu)->chan = NULL;
list_for_each_entry(device, &dma_device... |
functions | void dma_release_channel(struct dma_chan *chan)
{
mutex_lock(&dma_list_mutex);
WARN_ONCE(chan->client_count != 1,
"chan reference count %d != 1\n", chan->client_count);
dma_chan_put(chan);
/* drop PRIVATE cap enabled by __dma_request_channel() */
if (--chan->device->privatecnt == 0)
dma_cap_clear(DMA_PRIVATE... |
functions | void dmaengine_get(void)
{
struct dma_device *device, *_d;
struct dma_chan *chan;
int err;
mutex_lock(&dma_list_mutex);
dmaengine_ref_count++;
/* try to grab channels */
list_for_each_entry_safe(device, _d, &dma_device_list, global_node) {
if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
continue;
list_f... |
functions | void dmaengine_put(void)
{
struct dma_device *device;
struct dma_chan *chan;
mutex_lock(&dma_list_mutex);
dmaengine_ref_count--;
BUG_ON(dmaengine_ref_count < 0);
/* drop channel references */
list_for_each_entry(device, &dma_device_list, global_node) {
if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
contin... |
functions | bool device_has_all_tx_types(struct dma_device *device)
{
/* A device that satisfies this test has channels that will never cause
* an async_tx channel switch event as all possible operation types can
* be handled.
*/
#ifdef CONFIG_ASYNC_TX_DMA
if (!dma_has_cap(DMA_INTERRUPT, device->cap_mask))
return false;... |
functions | int get_dma_id(struct dma_device *device)
{
int rc;
idr_retry:
if (!idr_pre_get(&dma_idr, GFP_KERNEL))
return -ENOMEM;
mutex_lock(&dma_list_mutex);
rc = idr_get_new(&dma_idr, NULL, &device->dev_id);
mutex_unlock(&dma_list_mutex);
if (rc == -EAGAIN)
goto idr_retry;
else if (rc != 0)
return rc;
return 0;... |
functions | int dma_async_device_register(struct dma_device *device)
{
int chancnt = 0, rc;
struct dma_chan* chan;
atomic_t *idr_ref;
if (!device)
return -ENODEV;
/* validate device routines */
BUG_ON(dma_has_cap(DMA_MEMCPY, device->cap_mask) &&
!device->device_prep_dma_memcpy);
BUG_ON(dma_has_cap(DMA_XOR, device->cap... |
functions | void dma_async_device_unregister(struct dma_device *device)
{
struct dma_chan *chan;
mutex_lock(&dma_list_mutex);
list_del_rcu(&device->global_node);
dma_channel_rebalance();
mutex_unlock(&dma_list_mutex);
list_for_each_entry(chan, &device->channels, device_node) {
WARN_ONCE(chan->client_count,
"%s calle... |
functions | dma_cookie_t
dma_async_memcpy_buf_to_buf(struct dma_chan *chan, void *dest,
void *src, size_t len)
{
struct dma_device *dev = chan->device;
struct dma_async_tx_descriptor *tx;
dma_addr_t dma_dest, dma_src;
dma_cookie_t cookie;
unsigned long flags;
dma_src = dma_map_single(dev->dev, src, len, DMA_TO_DEVICE);
... |
functions | dma_cookie_t
dma_async_memcpy_buf_to_pg(struct dma_chan *chan, struct page *page,
unsigned int offset, void *kdata, size_t len)
{
struct dma_device *dev = chan->device;
struct dma_async_tx_descriptor *tx;
dma_addr_t dma_dest, dma_src;
dma_cookie_t cookie;
unsigned long flags;
dma_src = dma_map_single(dev->dev... |
functions | dma_cookie_t
dma_async_memcpy_pg_to_pg(struct dma_chan *chan, struct page *dest_pg,
unsigned int dest_off, struct page *src_pg, unsigned int src_off,
size_t len)
{
struct dma_device *dev = chan->device;
struct dma_async_tx_descriptor *tx;
dma_addr_t dma_dest, dma_src;
dma_cookie_t cookie;
unsigned long flags;
... |
functions | void dma_async_tx_descriptor_init(struct dma_async_tx_descriptor *tx,
struct dma_chan *chan)
{
tx->chan = chan;
<<<<<<< HEAD
#ifdef CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH
=======
#ifndef CONFIG_ASYNC_TX_DISABLE_CHANNEL_SWITCH
>>>>>>> 296c66da8a02d52243f45b80521febece5ed498a
spin_lock_init(&tx->lock);
#endif
} |
functions | dma_status
dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx)
{
unsigned long dma_sync_wait_timeout = jiffies + msecs_to_jiffies(5000);
if (!tx)
return DMA_SUCCESS;
while (tx->cookie == -EBUSY) {
if (time_after_eq(jiffies, dma_sync_wait_timeout)) {
pr_err("%s timeout waiting for descriptor submission... |
functions | void dma_run_dependencies(struct dma_async_tx_descriptor *tx)
{
struct dma_async_tx_descriptor *dep = txd_next(tx);
struct dma_async_tx_descriptor *dep_next;
struct dma_chan *chan;
if (!dep)
return;
/* we'll submit tx->next now, so clear the link */
txd_clear_next(tx);
chan = dep->chan;
/* keep submitting ... |
functions | __init dma_bus_init(void)
{
idr_init(&dma_idr);
mutex_init(&dma_list_mutex);
return class_register(&dma_devclass);
} |
includes | #include <linux/module.h> |
includes | #include <linux/kernel.h> |
includes | #include <linux/io.h> |
includes | #include <linux/slab.h> |
includes | #include <linux/pm_runtime.h> |
includes | #include <linux/interrupt.h> |
includes | #include <linux/device.h> |
includes | #include <linux/platform_device.h> |
includes | #include <linux/usb/phy.h> |
includes | #include <linux/usb/otg.h> |
includes | #include <linux/notifier.h> |
includes | #include <linux/extcon.h> |
includes | #include <linux/power_supply.h> |
includes | #include <linux/wakelock.h> |
includes | #include <linux/mfd/intel_soc_pmic.h> |
includes | #include <linux/extcon/extcon-dc-pwrsrc.h> |
includes | #include <linux/gpio.h> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.