unique
pcb_va->unique = 0;
pcb_va->unique = 0;
pcb_va->unique = 0;
unsigned long unique;
current_thread_info()->pcb.unique = 0;
childti->pcb.unique = tls;
dest[32] = ti->pcb.unique;
addr = &task_thread_info(task)->pcb.unique;
hwpcb->unique = virt_to_phys(ipcb);
hwpcb->ksp, hwpcb->ptbr, hwrpb->vptb, hwpcb->unique));
unsigned long *freq, unsigned long *unique)
*unique = pdc_result[2];
unsigned long freq, unique;
ret = pdc_pat_pd_get_platform_counter(&pclock, &freq, &unique);
pclock, freq, unique);
if (master && master->unique)
seq_printf(m, " master=%s", master->unique);
if (dev->unique)
seq_printf(m, " unique=%s", dev->unique);
r, adev_to_drm(tmp_adev)->unique);
adev->asic_reset_res, adev_to_drm(adev)->unique);
r, adev_to_drm(tmp_adev)->unique);
r, adev_to_drm(tmp_adev)->unique);
sysfs_remove_link(&adev->dev->kobj, adev_to_drm(adev)->unique);
adev_to_drm(adev)->unique,
kfree(master->unique);
client = kasprintf(GFP_KERNEL, "../%s", file->minor->dev->unique);
dev->debugfs_root = debugfs_create_dir(dev->unique, accel_debugfs_root);
dev->debugfs_root = debugfs_create_dir(dev->unique, drm_debugfs_root);
dev->unique);
if (master && master->unique)
seq_printf(m, " master=%s", master->unique);
if (dev->unique)
seq_printf(m, " unique=%s", dev->unique);
dev->unique = drmm_kstrdup(dev, dev_name(parent), GFP_KERNEL);
if (!dev->unique) {
region = dmem_cgroup_register_region(size, "drm/%s/%s", dev->unique, region_name);
u32 unique; /* Unique name for driver instantiation */
.unique = compat_ptr(uq32.unique),
if (copy_to_user(u->unique, master->unique, master->unique_len)) {
kfree(master->unique);
master->unique = NULL;
if (master->unique != NULL)
WARN_ON(!dev->unique);
master->unique = kstrdup(dev->unique, GFP_KERNEL);
if (master->unique)
master->unique_len = strlen(dev->unique);
shrink = shrinker_alloc(0, "drm-drm_pagemap:%s", drm->unique);
master->unique = kasprintf(GFP_KERNEL, "pci:%04x:%02x:%02x.%d",
if (!master->unique)
master->unique_len = strlen(master->unique);
__string( dev_name, dev->unique )
uint64_t unique;
uint32_t unique;
uint64_t unique;
cursor.header.unique = 0;
shrinker->shrink = shrinker_alloc(0, "drm-xe_gem:%s", xe->drm.unique);
dpagemap ? dpagemap->drm->unique : "System.");
dpagemap->drm->unique);
dpagemap ? dpagemap->drm->unique : "system",
set_bit(0, priv->cfp.unique);
DECLARE_BITMAP(unique, CFP_NUM_RULES);
clear_bit(loc, priv->cfp.unique);
if (!test_bit(loc, priv->cfp.unique) || loc == 0)
for_each_set_bit_from(index, priv->cfp.unique, priv->num_cfp_rules) {
nfc->rule_cnt = bitmap_weight(priv->cfp.unique,
set_bit(rule_index, priv->cfp.unique);
set_bit(rule_index[1], priv->cfp.unique);
u32 unique; // unique value representing this context
fibctx->unique = (u32)((ulong)fibctx & 0xFFFFFFFF);
if (context->unique == fibctx->unique) {
fibctx->unique++;
if (copy_to_user(arg, &fibctx->unique,
sizeof(fibctx->unique))) {
if (fibctx->unique == f.fibctx) { /* We found a winner */
if (fibctx->unique == (u32)(uintptr_t)arg) /* We found a winner */
bool unique = true;
unique = false;
if (unique) {
u32 unique; /* unique ID number (file index version) */
} else if (cbb->fid.vnode == 0 && cbb->fid.unique == 0) {
cbb->fid.unique);
cb->fid.unique = ntohl(*bp++);
cb->fid.unique = ntohl(bp->vnode.unique);
if (fid.unique != vnode->fid.unique) {
dentry, fid.unique,
vnode->fid.unique,
ntohl(dire->u.unique)))
ntohl(dire->u.unique)))
cookie->fid.unique = uniquifier;
_leave(" = 0 { vn=%llu u=%u }", fid->vnode, fid->unique);
cookie->fids[cookie->nr_fids].unique = uniquifier;
vp->fid.vid, vp->fid.vnode, vp->fid.unique);
new_fid->vnode, new_fid->unique, name->name);
de->u.unique = htonl(new_fid->unique);
ntohl(de->u.vnode), ntohl(de->u.unique),
vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique,
vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique,
de->u.unique = htonl(new_dvnode->fid.unique);
ntohl(de->u.vnode), ntohl(de->u.unique), name->name);
de->u.unique = htonl(dvnode->fid.unique);
dvnode->fid.vnode, dvnode->fid.unique, ".");
de->u.unique = htonl(parent_dvnode->fid.unique);
parent_dvnode->fid.vnode, parent_dvnode->fid.unique, "..");
_fid->unique = ntohl(dire->u.unique);
struct afs_fid fid = { .vnode = ino, .unique = 1, };
struct afs_fid fid = { .vid = 0, .vnode = 1, .unique = 1,};
inode->i_generation = fid->unique;
struct afs_fid fid = { .vnode = ino, .unique = 1, };
inode, inode->i_ino, fid.vid, fid.vnode, fid.unique);
vnode->fid.unique,
vnode->fid.unique,
vnode->fid.unique,
vnode->fid.unique,
index, vp->fid.vid, vp->fid.vnode, vp->fid.unique);
*bp++ = htonl(orig_dvp->fid.unique);
*bp++ = htonl(new_dvp->fid.unique);
*bp++ = htonl(vp->fid.unique);
*bp++ = htonl(vp->fid.unique);
*bp++ = htonl(vp->fid.unique);
*bp++ = htonl(vp->fid.unique);
*bp++ = htonl(vp->fid.unique);
*bp++ = htonl(vp->fid.unique);
*bp++ = htonl(vp->fid.unique);
*bp++ = htonl(vp->fid.unique);
*bp++ = htonl(dvp->fid.unique);
*bp++ = htonl(vp->fid.unique);
*bp++ = htonl(op->more_files[i].fid.unique);
bp[3] = htonl(vp->fid.unique);
bp[3] = htonl(vp->fid.unique);
fid->unique = ntohl(*bp++);
bp[3] = htonl(vp->fid.unique);
bp[3] = htonl(vp->fid.unique);
bp[3] = htonl(vp->fid.unique);
*bp++ = htonl(dvp->fid.unique);
*bp++ = htonl(dvp->fid.unique);
*bp++ = htonl(dvp->fid.unique);
*bp++ = htonl(dvp->fid.unique);
*bp++ = htonl(dvp->fid.unique);
*bp++ = htonl(vp->fid.unique);
*bp++ = htonl(dvp->fid.unique);
vp->fid.vid, vp->fid.vnode, vp->fid.unique,
vnode->fid.unique,
vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique,
fid->unique == vnode->fid.unique);
vnode->fid.unique);
inode->i_generation = vnode->fid.unique;
__be32 unique;
parent_vnode->fid.unique);
key.unique = htonl(vnode->fid.unique);
_enter(",{%llx:%llu.%u},,", vp->fid.vid, vp->fid.vnode, vp->fid.unique);
inode, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
vnode->fid.unique = 1;
vnode->fid.unique);
vp->fid.vid, vp->fid.vnode, vp->fid.unique,
__be32 unique;
vnode->fid.unique,
vnode->fid.unique);
__be32 unique;
fid->unique = ntohl(x->vnode.unique);
x->vnode.unique = htonl(fid->unique);
hdr.opcode, hdr.unique);
hdr.opcode, hdr.unique);
if (tmp->uc_unique == hdr.unique) {
__func__, hdr.opcode, hdr.unique);
hdr.opcode, hdr.unique);
buffer->ih.unique = ++vcp->vc_seq;
req->uc_unique = buffer->ih.unique;
sig_inputArgs->ih.unique = req->uc_unique;
sig_req->uc_unique = sig_inputArgs->ih.unique;
.unique = req->in.h.unique,
.unique = (req->in.h.unique | FUSE_INT_REQ_BIT),
.unique = fuse_get_unique_locked(fiq),
.unique = fuse_get_unique_locked(fiq),
hash = fuse_req_hash(req->in.h.unique);
req->in.h.unique |= FUSE_UNIQUE_RESEND;
struct fuse_req *fuse_request_find(struct fuse_pqueue *fpq, u64 unique)
unsigned int hash = fuse_req_hash(unique);
if (req->in.h.unique == unique)
if (!oh.unique) {
req = fuse_request_find(fpq, oh.unique & ~FUSE_INT_REQ_BIT);
if (oh.unique & FUSE_INT_REQ_BIT) {
unsigned int fuse_req_hash(u64 unique)
return hash_long(unique & ~FUSE_INT_REQ_BIT, FUSE_PQ_HASH_BITS);
req->in.h.unique = fuse_get_unique_locked(fiq);
req->in.h.unique = fuse_get_unique(fiq);
int fuse_chan_send_notify_reply(struct fuse_chan *fch, struct fuse_args *args, u64 unique)
req->in.h.unique = unique;
int fuse_chan_send_notify_reply(struct fuse_chan *fch, struct fuse_args *args, u64 unique);
if (oh->unique == 0) {
if ((oh->unique & ~FUSE_INT_REQ_BIT) != req->in.h.unique) {
req->in.h.unique,
oh->unique & ~FUSE_INT_REQ_BIT);
WARN_ON_ONCE(oh->unique & FUSE_INT_REQ_BIT);
.commit_id = req->in.h.unique,
if (WARN_ON(req->in.h.unique == 0))
hash = fuse_req_hash(req->in.h.unique);
unsigned int fuse_req_hash(u64 unique);
struct fuse_req *fuse_request_find(struct fuse_pqueue *fpq, u64 unique);
int fuse_simple_notify_reply(struct fuse_mount *fm, struct fuse_args *args, u64 unique);
__entry->connection, __entry->unique, __entry->opcode,
__field(uint64_t, unique)
__entry->unique = req->in.h.unique;
__entry->connection, __entry->unique, __entry->opcode,
__field(uint64_t, unique)
__entry->unique = req->in.h.unique;
__entry->unique, __entry->len, __entry->error)
__field(uint64_t, unique)
__entry->unique = req->in.h.unique;
int fuse_simple_notify_reply(struct fuse_mount *fm, struct fuse_args *args, u64 unique)
return fuse_chan_send_notify_reply(fc->chan, args, unique);
u64 unique = fuse_get_unique(fiq);
.unique = unique,
hash = fuse_req_hash(req->in.h.unique);
__func__, req->in.h.opcode, req->in.h.unique,
if (oh->unique != req->in.h.unique) {
oh->unique, req->in.h.unique);
const int unique = !is_hash_key(c, key);
if (unique)
char *unique;
char *unique;
__entry->dfid.vid, __entry->dfid.vnode, __entry->dfid.unique,
__entry->fid.vnode, __entry->fid.unique)
__field(unsigned int, unique)
__entry->unique = dvnode->fid.unique;
__entry->vnode, __entry->unique,
__field(unsigned int, unique)
__entry->unique = dvnode->fid.unique;
__entry->vnode, __entry->unique,
__field(unsigned int, unique)
__entry->unique = vnode->fid.unique;
__entry->vnode, __entry->unique,
__field(unsigned int, unique)
__entry->unique = vnode->fid.unique;
__entry->vnode, __entry->unique,
__field(unsigned int, unique)
__entry->unique = dvnode->fid.unique;
__entry->vnode, __entry->unique,
__field(unsigned int, unique)
__entry->unique = dvnode->fid.unique;
__entry->vnode, __entry->unique,
__entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
__entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
__entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
__entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
__entry->fid.vid, __entry->fid.vnode, __entry->fid.unique)
__entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
__entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
__entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
__entry->fid.unique)
__entry->fid.unique = 0;
__entry->fid.unique,
__entry->fid.unique = 0;
__entry->fid.unique,
__entry->fid.unique = 0;
__entry->fid.unique,
__entry->fid.unique = 0;
__entry->fid.unique,
char __user *unique; /**< Unique name for driver instantiation */
u_int32_t unique; /* Keep multiple outstanding msgs distinct */
u_int32_t unique;
uint64_t unique;
uint64_t unique;
uint64_t unique;
int unique = 1;
if (items[i] != items[unique - 1])
items[unique++] = items[i];
return unique;
dups = unique(vec, n);
bool unique)
return unique ? NULL : id;
char __user *unique; /**< Unique name for driver instantiation */