arch/arm/mach-omap2/soc.h

108

#define IS_OMAP_SUBCLASS(subclass, id) \

arch/arm/mach-omap2/soc.h

109

static inline int is_omap ##subclass (void) \

arch/arm/mach-omap2/soc.h

114

#define IS_TI_SUBCLASS(subclass, id) \

arch/arm/mach-omap2/soc.h

115

static inline int is_ti ##subclass (void) \

arch/arm/mach-omap2/soc.h

120

#define IS_AM_SUBCLASS(subclass, id) \

arch/arm/mach-omap2/soc.h

121

static inline int is_am ##subclass (void) \

arch/arm/mach-omap2/soc.h

126

#define IS_DRA_SUBCLASS(subclass, id) \

arch/arm/mach-omap2/soc.h

127

static inline int is_dra ##subclass (void) \

arch/arm/mach-omap2/soc.h

134

#define IS_DRA_SUBCLASS_PACKAGE(subclass, package, id) \

arch/arm/mach-omap2/soc.h

135

static inline int is_dra ##subclass ##_ ##package (void) \

arch/arm/mach-omap2/soc.h

137

return (is_dra ##subclass () && GET_DRA_PACKAGE == id) ? 1 : 0; \

arch/s390/include/asm/irq.h

118

void irq_subclass_register(enum irq_subclass subclass);

arch/s390/include/asm/irq.h

119

void irq_subclass_unregister(enum irq_subclass subclass);

arch/s390/kernel/irq.c

410

void irq_subclass_register(enum irq_subclass subclass)

arch/s390/kernel/irq.c

413

if (!irq_subclass_refcount[subclass])

arch/s390/kernel/irq.c

414

system_ctl_set_bit(0, subclass);

arch/s390/kernel/irq.c

415

irq_subclass_refcount[subclass]++;

arch/s390/kernel/irq.c

420

void irq_subclass_unregister(enum irq_subclass subclass)

arch/s390/kernel/irq.c

423

irq_subclass_refcount[subclass]--;

arch/s390/kernel/irq.c

424

if (!irq_subclass_refcount[subclass])

arch/s390/kernel/irq.c

425

system_ctl_clear_bit(0, subclass);

drivers/clk/zynqmp/clkc.c

690

u32 nodetype, subclass, class;

drivers/clk/zynqmp/clkc.c

709

subclass = FIELD_GET(CLK_ATTR_NODE_SUBCLASS, attr.attr[0]);

drivers/clk/zynqmp/clkc.c

713

FIELD_PREP(CLK_ATTR_NODE_SUBCLASS, subclass) |

drivers/cxl/core/edac.c

835

u8 subclass, void *data_in,

drivers/cxl/core/edac.c

851

pi->hdr.op_subclass = subclass;

drivers/gpu/drm/i915/gt/intel_gtt.c

261

void i915_address_space_init(struct i915_address_space *vm, int subclass)

drivers/gpu/drm/i915/gt/intel_gtt.c

281

lockdep_set_subclass(&vm->mutex, subclass);

drivers/gpu/drm/i915/gt/intel_gtt.h

528

void i915_address_space_init(struct i915_address_space *vm, int subclass);

drivers/gpu/drm/i915/i915_scheduler.c

452

i915_sched_engine_create(unsigned int subclass)

drivers/gpu/drm/i915/i915_scheduler.c

471

lockdep_set_subclass(&sched_engine->lock, subclass);

drivers/gpu/drm/i915/i915_scheduler.h

53

i915_sched_engine_create(unsigned int subclass);

drivers/nvdimm/security.c

110

down_read_nested(&key->sem, subclass);

drivers/nvdimm/security.c

121

key_serial_t id, int subclass, struct key **key)

drivers/nvdimm/security.c

125

if (subclass == NVDIMM_BASE_KEY)

drivers/nvdimm/security.c

131

*key = nvdimm_lookup_user_key(nvdimm, id, subclass);

drivers/nvdimm/security.c

91

key_serial_t id, int subclass)

drivers/pci/controller/pci-hyperv.c

177

u8 subclass;

drivers/pci/controller/pci-hyperv.c

194

u8 subclass;

drivers/pci/controller/pci-hyperv.c

2892

dr->func[i].subclass = relations->func[i].subclass;

drivers/pci/controller/pci-hyperv.c

2926

dr->func[i].subclass = relations->func[i].subclass;

drivers/pci/controller/pci-hyperv.c

535

u8 subclass;

drivers/s390/char/raw3270.c

1017

lockdep_set_subclass(&view->lock, subclass);

drivers/s390/char/raw3270.c

995

int minor, int subclass)

drivers/s390/char/raw3270.h

86

int raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor, int subclass);

drivers/tty/tty_ldsem.c

296

int subclass, long timeout)

drivers/tty/tty_ldsem.c

300

rwsem_acquire_read(&sem->dep_map, subclass, 0, _RET_IP_);

drivers/tty/tty_ldsem.c

315

int subclass, long timeout)

drivers/tty/tty_ldsem.c

319

rwsem_acquire(&sem->dep_map, subclass, 0, _RET_IP_);

drivers/tty/tty_ldsem.c

400

int ldsem_down_read_nested(struct ld_semaphore *sem, int subclass, long timeout)

drivers/tty/tty_ldsem.c

403

return __ldsem_down_read_nested(sem, subclass, timeout);

drivers/tty/tty_ldsem.c

406

int ldsem_down_write_nested(struct ld_semaphore *sem, int subclass,

drivers/tty/tty_ldsem.c

410

return __ldsem_down_write_nested(sem, subclass, timeout);

drivers/usb/gadget/function/f_hid.c

1381

F_HID_OPT(subclass, 8, 255);

drivers/usb/gadget/function/f_hid.c

1627

hidg->bInterfaceSubClass = opts->subclass;

drivers/usb/gadget/function/f_rndis.c

685

rndis_iad_descriptor.bFunctionSubClass = rndis_opts->subclass;

drivers/usb/gadget/function/f_rndis.c

850

USB_ETHER_CONFIGFS_ITEM_ATTR_U8_RW(rndis, subclass);

drivers/usb/gadget/function/f_rndis.c

911

opts->subclass = rndis_iad_descriptor.bFunctionSubClass;

drivers/usb/gadget/function/u_hid.h

21

unsigned char subclass;

drivers/usb/gadget/function/u_rndis.h

53

u8 subclass;

drivers/usb/gadget/legacy/hid.c

152

hid_opts->subclass = iter_n->func->subclass;

drivers/usb/storage/scsiglue.c

160

if (us->subclass != USB_SC_SCSI && us->subclass != USB_SC_CYP_ATACB)

drivers/usb/storage/scsiglue.c

352

if (us->subclass == USB_SC_UFI)

drivers/usb/storage/transport.c

1027

if (us->subclass == USB_SC_UFI) {

drivers/usb/storage/transport.c

722

if (us->subclass == USB_SC_RBC || us->subclass == USB_SC_SCSI ||

drivers/usb/storage/transport.c

723

us->subclass == USB_SC_CYP_ATACB)

drivers/usb/storage/usb.c

680

us->subclass = (unusual_dev->useProtocol == USB_SC_DEVICE) ?

drivers/usb/storage/usb.c

722

us->subclass == idesc->bInterfaceSubClass)

drivers/usb/storage/usb.c

776

switch (us->subclass) {

drivers/usb/storage/usb.h

110

u8 subclass;

fs/ext4/super.c

7116

static void lockdep_set_quota_inode(struct inode *inode, int subclass)

fs/ext4/super.c

7127

lockdep_set_subclass(&ei->i_data_sem, subclass);

fs/f2fs/f2fs.h

2433

static inline void f2fs_down_read_nested(struct f2fs_rwsem *sem, int subclass)

fs/f2fs/f2fs.h

2435

down_read_nested(&sem->internal_rwsem, subclass);

fs/f2fs/f2fs.h

2438

static inline void f2fs_down_write_nested(struct f2fs_rwsem *sem, int subclass)

fs/f2fs/f2fs.h

2440

down_write_nested(&sem->internal_rwsem, subclass);

fs/f2fs/f2fs.h

2443

#define f2fs_down_read_nested(sem, subclass) f2fs_down_read(sem)

fs/f2fs/f2fs.h

2444

#define f2fs_down_write_nested(sem, subclass) f2fs_down_write(sem)

fs/jfs/jfs_incore.h

108

#define IREAD_LOCK(ip, subclass) \

fs/jfs/jfs_incore.h

109

down_read_nested(&JFS_IP(ip)->rdwrlock, subclass)

fs/jfs/jfs_incore.h

111

#define IWRITE_LOCK(ip, subclass) \

fs/jfs/jfs_incore.h

112

down_write_nested(&JFS_IP(ip)->rdwrlock, subclass)

fs/ocfs2/dlmglue.c

2430

int subclass)

fs/ocfs2/dlmglue.c

2466

arg_flags, subclass, _RET_IP_);

fs/ocfs2/dlmglue.h

139

int subclass);

fs/xfs/xfs_inode.c

324

int subclass)

fs/xfs/xfs_inode.c

326

return subclass < MAX_LOCKDEP_SUBCLASSES;

fs/xfs/xfs_inode.c

329

#define xfs_lockdep_subclass_ok(subclass) (true)

fs/xfs/xfs_inode.c

341

uint subclass)

fs/xfs/xfs_inode.c

346

ASSERT(xfs_lockdep_subclass_ok(subclass));

fs/xfs/xfs_inode.c

349

ASSERT(subclass <= XFS_IOLOCK_MAX_SUBCLASS);

fs/xfs/xfs_inode.c

350

class += subclass << XFS_IOLOCK_SHIFT;

fs/xfs/xfs_inode.c

354

ASSERT(subclass <= XFS_MMAPLOCK_MAX_SUBCLASS);

fs/xfs/xfs_inode.c

355

class += subclass << XFS_MMAPLOCK_SHIFT;

fs/xfs/xfs_inode.c

359

ASSERT(subclass <= XFS_ILOCK_MAX_SUBCLASS);

fs/xfs/xfs_inode.c

360

class += subclass << XFS_ILOCK_SHIFT;

include/linux/fs.h

1067

static inline void inode_lock_nested(struct inode *inode, unsigned subclass)

include/linux/fs.h

1069

down_write_nested(&inode->i_rwsem, subclass);

include/linux/fs.h

1072

static inline void inode_lock_shared_nested(struct inode *inode, unsigned subclass)

include/linux/fs.h

1074

down_read_nested(&inode->i_rwsem, subclass);

include/linux/lockdep.h

129

struct lock_class_key *key, int subclass, u8 inner, u8 outer, u8 lock_type);

include/linux/lockdep.h

133

struct lock_class_key *key, int subclass, u8 inner, u8 outer)

include/linux/lockdep.h

135

lockdep_init_map_type(lock, name, key, subclass, inner, outer, LD_LOCK_NORMAL);

include/linux/lockdep.h

140

struct lock_class_key *key, int subclass, u8 inner)

include/linux/lockdep.h

142

lockdep_init_map_waits(lock, name, key, subclass, inner, LD_WAIT_INV);

include/linux/lockdep.h

146

struct lock_class_key *key, int subclass)

include/linux/lockdep.h

148

lockdep_init_map_wait(lock, name, key, subclass, LD_WAIT_INV);

include/linux/lockdep.h

227

extern void lock_acquire(struct lockdep_map *lock, unsigned int subclass,

include/linux/lockdep.h

233

extern void lock_sync(struct lockdep_map *lock, unsigned int subclass,

include/linux/lockdep.h

256

struct lock_class_key *key, unsigned int subclass,

include/linux/lockdep.h

263

unsigned int subclass, unsigned long ip)

include/linux/lockdep.h

265

lock_set_class(lock, lock->name, lock->key, subclass, ip);

include/linux/lockdep.h

561

# define might_lock_nested(lock, subclass) \

include/linux/lockdep.h

564

lock_acquire(&(lock)->dep_map, subclass, 0, 1, 1, NULL, \

include/linux/lockdep.h

627

# define might_lock_nested(lock, subclass) do { } while (0)

include/linux/lockdep_types.h

122

unsigned int subclass;

include/linux/maple_tree.h

306

#define mtree_lock_nested(mas, subclass) \

include/linux/maple_tree.h

307

spin_lock_nested((&(mt)->ma_lock), subclass)

include/linux/maple_tree.h

507

#define mas_lock_nested(mas, subclass) \

include/linux/maple_tree.h

508

spin_lock_nested(&((mas)->tree->ma_lock), subclass)

include/linux/mmap_lock.h

238

static inline bool vma_start_read_locked_nested(struct vm_area_struct *vma, int subclass)

include/linux/mmap_lock.h

541

static inline void mmap_write_lock_nested(struct mm_struct *mm, int subclass)

include/linux/mmap_lock.h

544

down_write_nested(&mm->mmap_lock, subclass);

include/linux/mutex.h

185

extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass) __acquires(lock);

include/linux/mutex.h

188

unsigned int subclass) __cond_acquires(0, lock);

include/linux/mutex.h

190

unsigned int subclass, struct lockdep_map *nest_lock) __cond_acquires(0, lock);

include/linux/mutex.h

191

extern void mutex_lock_io_nested(struct mutex *lock, unsigned int subclass) __acquires(lock);

include/linux/mutex.h

210

#define mutex_lock_killable_nested(lock, subclass) \

include/linux/mutex.h

211

_mutex_lock_killable(lock, subclass, NULL)

include/linux/mutex.h

219

# define mutex_lock_nested(lock, subclass) mutex_lock(lock)

include/linux/mutex.h

220

# define mutex_lock_interruptible_nested(lock, subclass) mutex_lock_interruptible(lock)

include/linux/mutex.h

221

# define mutex_lock_killable_nested(lock, subclass) mutex_lock_killable(lock)

include/linux/mutex.h

224

# define mutex_lock_io_nested(lock, subclass) mutex_lock_io(lock)

include/linux/rhashtable.h

337

unsigned int subclass)

include/linux/rhashtable.h

344

lock_acquire_exclusive(&tbl->dep_map, subclass, 0, NULL, _THIS_IP_);

include/linux/rtmutex.h

113

extern void rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass)

include/linux/rtmutex.h

126

#define rt_mutex_lock_nested(lock, subclass) rt_mutex_lock(lock)

include/linux/rwlock.h

69

#define write_lock_nested(lock, subclass) _raw_write_lock_nested(lock, subclass)

include/linux/rwlock.h

71

#define write_lock_nested(lock, subclass) _raw_write_lock(lock)

include/linux/rwlock_api_smp.h

20

void __lockfunc _raw_write_lock_nested(rwlock_t *lock, int subclass) __acquires(lock);

include/linux/rwlock_api_smp.h

233

static inline void __raw_write_lock_nested(rwlock_t *lock, int subclass)

include/linux/rwlock_api_smp.h

237

rwlock_acquire(&lock->dep_map, subclass, 0, _RET_IP_);

include/linux/rwlock_rt.h

102

#define write_lock_nested(lock, subclass) rt_write_lock(((void)(subclass), (lock)))

include/linux/rwlock_rt.h

31

extern void rt_write_lock_nested(rwlock_t *rwlock, int subclass) __acquires(rwlock);

include/linux/rwlock_rt.h

96

static __always_inline void write_lock_nested(rwlock_t *rwlock, int subclass)

include/linux/rwlock_rt.h

99

rt_write_lock_nested(rwlock, subclass);

include/linux/rwsem.h

304

extern void down_read_nested(struct rw_semaphore *sem, int subclass) __acquires_shared(sem);

include/linux/rwsem.h

305

extern int __must_check down_read_killable_nested(struct rw_semaphore *sem, int subclass) __cond_acquires_shared(0, sem);

include/linux/rwsem.h

306

extern void down_write_nested(struct rw_semaphore *sem, int subclass) __acquires(sem);

include/linux/rwsem.h

307

extern int down_write_killable_nested(struct rw_semaphore *sem, int subclass) __cond_acquires(0, sem);

include/linux/rwsem.h

325

# define down_read_nested(sem, subclass) down_read(sem)

include/linux/rwsem.h

326

# define down_read_killable_nested(sem, subclass) down_read_killable(sem)

include/linux/rwsem.h

328

# define down_write_nested(sem, subclass) down_write(sem)

include/linux/rwsem.h

329

# define down_write_killable_nested(sem, subclass) down_write_killable(sem)

include/linux/seqlock.h

466

#define write_seqcount_begin_nested(s, subclass) \

include/linux/seqlock.h

473

do_write_seqcount_begin_nested(seqprop_ptr(s), subclass); \

include/linux/seqlock.h

476

static inline void do_write_seqcount_begin_nested(seqcount_t *s, int subclass)

include/linux/seqlock.h

478

seqcount_acquire(&s->dep_map, subclass, 0, _RET_IP_);

include/linux/soc/ti/omap1-soc.h

69

#define IS_OMAP_SUBCLASS(subclass, id) \

include/linux/soc/ti/omap1-soc.h

70

static inline int is_omap ##subclass (void) \

include/linux/spinlock.h

221

# define raw_spin_lock_nested(lock, subclass) \

include/linux/spinlock.h

222

_raw_spin_lock_nested(lock, subclass)

include/linux/spinlock.h

235

# define raw_spin_lock_nested(lock, subclass) \

include/linux/spinlock.h

236

_raw_spin_lock(((void)(subclass), (lock)))

include/linux/spinlock.h

249

#define raw_spin_lock_irqsave_nested(lock, flags, subclass) \

include/linux/spinlock.h

252

flags = _raw_spin_lock_irqsave_nested(lock, subclass); \

include/linux/spinlock.h

255

#define raw_spin_lock_irqsave_nested(lock, flags, subclass) \

include/linux/spinlock.h

270

#define raw_spin_lock_irqsave_nested(lock, flags, subclass) \

include/linux/spinlock.h

357

#define spin_lock_nested(lock, subclass) \

include/linux/spinlock.h

359

raw_spin_lock_nested(spinlock_check(lock), subclass); \

include/linux/spinlock.h

381

#define spin_lock_irqsave_nested(lock, flags, subclass) \

include/linux/spinlock.h

383

raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \

include/linux/spinlock_api_smp.h

23

void __lockfunc _raw_spin_lock_nested(raw_spinlock_t *lock, int subclass)

include/linux/spinlock_api_smp.h

35

_raw_spin_lock_irqsave_nested(raw_spinlock_t *lock, int subclass)

include/linux/spinlock_api_up.h

65

#define _raw_spin_lock_nested(lock, subclass) __LOCK(lock)

include/linux/spinlock_api_up.h

68

#define _raw_write_lock_nested(lock, subclass) __LOCK(lock)

include/linux/spinlock_rt.h

35

extern void rt_spin_lock_nested(spinlock_t *lock, int subclass) __acquires(lock);

include/linux/spinlock_rt.h

49

# define __spin_lock_nested(lock, subclass) \

include/linux/spinlock_rt.h

50

rt_spin_lock_nested(lock, subclass)

include/linux/spinlock_rt.h

57

# define __spin_lock_irqsave_nested(lock, flags, subclass) \

include/linux/spinlock_rt.h

61

__spin_lock_nested(lock, subclass); \

include/linux/spinlock_rt.h

70

# define __spin_lock_nested(lock, subclass) spin_lock(((void)(subclass), (lock)))

include/linux/spinlock_rt.h

71

# define __spin_lock_nest_lock(lock, subclass) spin_lock(((void)(subclass), (lock)))

include/linux/spinlock_rt.h

72

# define __spin_lock_irqsave_nested(lock, flags, subclass) \

include/linux/spinlock_rt.h

73

spin_lock_irqsave(((void)(subclass), (lock)), flags)

include/linux/spinlock_rt.h

76

#define spin_lock_nested(lock, subclass) \

include/linux/spinlock_rt.h

77

__spin_lock_nested(lock, subclass)

include/linux/spinlock_rt.h

82

#define spin_lock_irqsave_nested(lock, flags, subclass) \

include/linux/spinlock_rt.h

83

__spin_lock_irqsave_nested(lock, flags, subclass)

include/linux/tty_ldisc.h

46

int ldsem_down_read_nested(struct ld_semaphore *sem, int subclass,

include/linux/tty_ldisc.h

48

int ldsem_down_write_nested(struct ld_semaphore *sem, int subclass,

include/linux/tty_ldisc.h

51

# define ldsem_down_read_nested(sem, subclass, timeout) \

include/linux/tty_ldisc.h

53

# define ldsem_down_write_nested(sem, subclass, timeout) \

include/linux/usb/g_hid.h

12

unsigned char subclass;

include/linux/xarray.h

546

#define xa_lock_nested(xa, subclass) \

include/linux/xarray.h

547

spin_lock_nested(&(xa)->xa_lock, subclass)

include/linux/xarray.h

548

#define xa_lock_bh_nested(xa, subclass) \

include/linux/xarray.h

549

spin_lock_bh_nested(&(xa)->xa_lock, subclass)

include/linux/xarray.h

550

#define xa_lock_irq_nested(xa, subclass) \

include/linux/xarray.h

551

spin_lock_irq_nested(&(xa)->xa_lock, subclass)

include/linux/xarray.h

552

#define xa_lock_irqsave_nested(xa, flags, subclass) \

include/linux/xarray.h

553

spin_lock_irqsave_nested(&(xa)->xa_lock, flags, subclass)

include/net/sock.h

1709

void lock_sock_nested(struct sock *sk, int subclass);

include/trace/events/lock.h

25

TP_PROTO(struct lockdep_map *lock, unsigned int subclass,

include/trace/events/lock.h

29

TP_ARGS(lock, subclass, trylock, read, check, next_lock, ip),

kernel/locking/lockdep.c

1285

register_lock_class(struct lockdep_map *lock, unsigned int subclass, int force)

kernel/locking/lockdep.c

1294

class = look_up_lock_class(lock, subclass);

kernel/locking/lockdep.c

1305

key = lock->key->subkeys + subclass;

kernel/locking/lockdep.c

1341

class->subclass = subclass;

kernel/locking/lockdep.c

1381

if (!subclass || force)

kernel/locking/lockdep.c

1383

else if (subclass < NR_LOCKDEP_CACHING_CLASSES)

kernel/locking/lockdep.c

1384

lock->class_cache[subclass] = class;

kernel/locking/lockdep.c

1390

if (DEBUG_LOCKS_WARN_ON(class->subclass != subclass))

kernel/locking/lockdep.c

4938

struct lock_class_key *key, int subclass,

kernel/locking/lockdep.c

4984

if (subclass) {

kernel/locking/lockdep.c

4992

register_lock_class(lock, subclass, 1);

kernel/locking/lockdep.c

5077

static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,

kernel/locking/lockdep.c

5103

if (DEBUG_LOCKS_WARN_ON(subclass >= MAX_LOCKDEP_SUBCLASSES))

kernel/locking/lockdep.c

5106

if (subclass < NR_LOCKDEP_CACHING_CLASSES)

kernel/locking/lockdep.c

5107

class = lock->class_cache[subclass];

kernel/locking/lockdep.c

5112

class = register_lock_class(lock, subclass, 0);

kernel/locking/lockdep.c

5386

hlock_class(hlock)->subclass,

kernel/locking/lockdep.c

5409

struct lock_class_key *key, unsigned int subclass,

kernel/locking/lockdep.c

5439

class = register_lock_class(lock, subclass, 0);

kernel/locking/lockdep.c

5734

struct lock_class_key *key, unsigned int subclass,

kernel/locking/lockdep.c

5745

if (__lock_set_class(lock, name, key, subclass, ip))

kernel/locking/lockdep.c

5770

static void verify_lock_unused(struct lockdep_map *lock, struct held_lock *hlock, int subclass)

kernel/locking/lockdep.c

5773

struct lock_class *class = look_up_lock_class(lock, subclass);

kernel/locking/lockdep.c

5825

void lock_acquire(struct lockdep_map *lock, unsigned int subclass,

kernel/locking/lockdep.c

5831

trace_lock_acquire(lock, subclass, trylock, read, check, nest_lock, ip);

kernel/locking/lockdep.c

5859

verify_lock_unused(lock, &hlock, subclass);

kernel/locking/lockdep.c

5868

__lock_acquire(lock, subclass, trylock, read, check,

kernel/locking/lockdep.c

5904

void lock_sync(struct lockdep_map *lock, unsigned subclass, int read,

kernel/locking/lockdep.c

5916

__lock_acquire(lock, subclass, 0, read, check,

kernel/locking/lockdep.c

730

if (class->subclass)

kernel/locking/lockdep.c

731

printk(KERN_CONT "/%d", class->subclass);

kernel/locking/lockdep.c

876

if (new_class->key - new_class->subclass == class->key)

kernel/locking/lockdep.c

887

look_up_lock_class(const struct lockdep_map *lock, unsigned int subclass)

kernel/locking/lockdep.c

893

if (unlikely(subclass >= MAX_LOCKDEP_SUBCLASSES)) {

kernel/locking/lockdep.c

898

"BUG: looking up invalid subclass: %u\n", subclass);

kernel/locking/lockdep.c

923

key = lock->key->subkeys + subclass;

kernel/locking/lockdep_proc.c

475

if (class->subclass)

kernel/locking/lockdep_proc.c

502

if (class->subclass) {

kernel/locking/lockdep_proc.c

503

snprintf(name+namelen, 3, "/%d", class->subclass);

kernel/locking/lockdep_proc.c

72

if (class->subclass)

kernel/locking/lockdep_proc.c

73

seq_printf(m, "/%d", class->subclass);

kernel/locking/mutex.c

609

__mutex_lock_common(struct mutex *lock, unsigned int state, unsigned int subclass,

kernel/locking/mutex.c

646

mutex_acquire_nest(&lock->dep_map, subclass, 0, nest_lock, ip);

kernel/locking/mutex.c

817

__mutex_lock(struct mutex *lock, unsigned int state, unsigned int subclass,

kernel/locking/mutex.c

821

return __mutex_lock_common(lock, state, subclass, nest_lock, ip, NULL, false);

kernel/locking/mutex.c

825

__ww_mutex_lock(struct mutex *lock, unsigned int state, unsigned int subclass,

kernel/locking/mutex.c

829

return __mutex_lock_common(lock, state, subclass, NULL, ip, ww_ctx, true);

kernel/locking/mutex.c

872

mutex_lock_nested(struct mutex *lock, unsigned int subclass)

kernel/locking/mutex.c

874

__mutex_lock(lock, TASK_UNINTERRUPTIBLE, subclass, NULL, _RET_IP_);

kernel/locking/mutex.c

889

_mutex_lock_killable(struct mutex *lock, unsigned int subclass,

kernel/locking/mutex.c

892

return __mutex_lock(lock, TASK_KILLABLE, subclass, nest, _RET_IP_);

kernel/locking/mutex.c

897

mutex_lock_interruptible_nested(struct mutex *lock, unsigned int subclass)

kernel/locking/mutex.c

899

return __mutex_lock(lock, TASK_INTERRUPTIBLE, subclass, NULL, _RET_IP_);

kernel/locking/mutex.c

904

mutex_lock_io_nested(struct mutex *lock, unsigned int subclass)

kernel/locking/mutex.c

912

subclass, NULL, _RET_IP_, NULL, 0);

kernel/locking/rtmutex_api.c

43

unsigned int subclass)

kernel/locking/rtmutex_api.c

49

mutex_acquire_nest(&lock->dep_map, subclass, 0, nest_lock, _RET_IP_);

kernel/locking/rtmutex_api.c

551

unsigned int subclass,

kernel/locking/rtmutex_api.c

559

mutex_acquire_nest(&lock->dep_map, subclass, 0, nest_lock, ip);

kernel/locking/rtmutex_api.c

576

void __sched mutex_lock_nested(struct mutex *lock, unsigned int subclass)

kernel/locking/rtmutex_api.c

578

__mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, subclass, NULL, _RET_IP_);

kernel/locking/rtmutex_api.c

590

unsigned int subclass)

kernel/locking/rtmutex_api.c

592

return __mutex_lock_common(lock, TASK_INTERRUPTIBLE, subclass, NULL, _RET_IP_);

kernel/locking/rtmutex_api.c

596

int __sched _mutex_lock_killable(struct mutex *lock, unsigned int subclass,

kernel/locking/rtmutex_api.c

599

return __mutex_lock_common(lock, TASK_KILLABLE, subclass, nest_lock, _RET_IP_);

kernel/locking/rtmutex_api.c

603

void __sched mutex_lock_io_nested(struct mutex *lock, unsigned int subclass)

kernel/locking/rtmutex_api.c

610

__mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, subclass, NULL, _RET_IP_);

kernel/locking/rtmutex_api.c

69

void __sched rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass)

kernel/locking/rtmutex_api.c

71

if (__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, NULL, subclass) == 0)

kernel/locking/rwsem.c

1705

void down_read_nested(struct rw_semaphore *sem, int subclass)

kernel/locking/rwsem.c

1709

rwsem_acquire_read(&sem->dep_map, subclass, 0, _RET_IP_);

kernel/locking/rwsem.c

1714

int down_read_killable_nested(struct rw_semaphore *sem, int subclass)

kernel/locking/rwsem.c

1718

rwsem_acquire_read(&sem->dep_map, subclass, 0, _RET_IP_);

kernel/locking/rwsem.c

1753

void down_write_nested(struct rw_semaphore *sem, int subclass)

kernel/locking/rwsem.c

1757

rwsem_acquire(&sem->dep_map, subclass, 0, _RET_IP_);

kernel/locking/rwsem.c

1762

int __sched down_write_killable_nested(struct rw_semaphore *sem, int subclass)

kernel/locking/rwsem.c

1766

rwsem_acquire(&sem->dep_map, subclass, 0, _RET_IP_);

kernel/locking/spinlock.c

309

#define __raw_write_lock_nested(lock, subclass) __raw_write_lock(((void)(subclass), (lock)))

kernel/locking/spinlock.c

312

void __lockfunc _raw_write_lock_nested(rwlock_t *lock, int subclass)

kernel/locking/spinlock.c

314

__raw_write_lock_nested(lock, subclass);

kernel/locking/spinlock.c

379

void __lockfunc _raw_spin_lock_nested(raw_spinlock_t *lock, int subclass)

kernel/locking/spinlock.c

382

spin_acquire(&lock->dep_map, subclass, 0, _RET_IP_);

kernel/locking/spinlock.c

388

int subclass)

kernel/locking/spinlock.c

394

spin_acquire(&lock->dep_map, subclass, 0, _RET_IP_);

kernel/locking/spinlock_rt.c

267

void __sched rt_write_lock_nested(rwlock_t *rwlock, int subclass) __acquires(RCU)

kernel/locking/spinlock_rt.c

270

rwlock_acquire(&rwlock->dep_map, subclass, 0, _RET_IP_);

kernel/locking/spinlock_rt.c

62

void __sched rt_spin_lock_nested(spinlock_t *lock, int subclass)

kernel/locking/spinlock_rt.c

64

spin_acquire(&lock->dep_map, subclass, 0, _RET_IP_);

kernel/sched/core.c

659

void raw_spin_rq_lock_nested(struct rq *rq, int subclass)

kernel/sched/core.c

667

raw_spin_lock_nested(&rq->__lock, subclass);

kernel/sched/core.c

675

raw_spin_lock_nested(lock, subclass);

kernel/sched/sched.h

1644

extern void raw_spin_rq_lock_nested(struct rq *rq, int subclass)

net/bluetooth/hidp/core.c

693

if (req->subclass & 0x40) {

net/bluetooth/hidp/core.c

709

if (req->subclass & 0x80) {

net/bluetooth/hidp/hidp.h

93

__u8 subclass;

net/bluetooth/hidp/sock.c

136

__u8 subclass;

net/bluetooth/hidp/sock.c

187

ca.subclass = ca32.subclass;

net/core/sock.c

3825

void noinline lock_sock_nested(struct sock *sk, int subclass)

net/core/sock.c

3828

mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);

scripts/mod/file2alias.c

425

unsigned char baseclass, subclass, interface,

scripts/mod/file2alias.c

455

subclass = (class) >> 8;

scripts/mod/file2alias.c

469

ADD(alias, "sc", subclass_mask == 0xFF, subclass);

sound/usb/mixer.c

3181

int subclass;

sound/usb/mixer.c

3195

.subclass = UAC3_FUNCTION_SUBCLASS_GENERIC_IO,

sound/usb/mixer.c

3202

.subclass = UAC3_FUNCTION_SUBCLASS_HEADPHONE,

sound/usb/mixer.c

3208

.subclass = UAC3_FUNCTION_SUBCLASS_SPEAKER,

sound/usb/mixer.c

3214

.subclass = UAC3_FUNCTION_SUBCLASS_MICROPHONE,

sound/usb/mixer.c

3224

.subclass = UAC3_FUNCTION_SUBCLASS_HEADSET,

sound/usb/mixer.c

3232

.subclass = UAC3_FUNCTION_SUBCLASS_HEADSET_ADAPTER,

sound/usb/mixer.c

3240

.subclass = UAC3_FUNCTION_SUBCLASS_SPEAKERPHONE,

sound/usb/mixer.c

3382

if (badd_profile == f->subclass)

sound/usb/mixer.c

3422

if (f->subclass == UAC3_FUNCTION_SUBCLASS_HEADSET_ADAPTER) {

tools/include/linux/rwsem.h

41

#define down_read_nested(sem, subclass) down_read(sem)

tools/include/linux/rwsem.h

42

#define down_write_nested(sem, subclass) down_write(sem)

tools/include/linux/spinlock.h

14

#define spin_lock_nested(x, subclass) pthread_mutex_lock(x)

tools/usb/usbip/libsrc/names.c

118

struct subclass *s;

tools/usb/usbip/libsrc/names.c

249

struct subclass *s;

tools/usb/usbip/libsrc/names.c

256

s = my_malloc(sizeof(struct subclass) + strlen(name));

tools/usb/usbip/libsrc/names.c

44

struct subclass *next;

tools/usb/usbip/libsrc/names.c

80

static struct subclass *subclasses[HASHSZ] = { NULL, };

tools/usb/usbip/libsrc/usbip_common.c

298

uint8_t subclass, uint8_t protocol)

tools/usb/usbip/libsrc/usbip_common.c

302

if (class == 0 && subclass == 0 && protocol == 0) {

tools/usb/usbip/libsrc/usbip_common.c

303

snprintf(buff, size, "(Defined at Interface level) (%02x/%02x/%02x)", class, subclass, protocol);

tools/usb/usbip/libsrc/usbip_common.c

307

p = names_protocol(class, subclass, protocol);

tools/usb/usbip/libsrc/usbip_common.c

311

s = names_subclass(class, subclass);

tools/usb/usbip/libsrc/usbip_common.c

319

snprintf(buff, size, "%s / %s / %s (%02x/%02x/%02x)", c, s, p, class, subclass, protocol);

tools/usb/usbip/libsrc/usbip_common.h

150

uint8_t subclass, uint8_t protocol);