arch/mips/include/asm/processor.h

259

union mips_watch_reg_state watch;

arch/mips/include/asm/processor.h

336

.watch = {{{0,},},}, \

arch/mips/kernel/ptrace.c

148

__put_user(child->thread.watch.mips3264.watchlo[i],

arch/mips/kernel/ptrace.c

150

__put_user(child->thread.watch.mips3264.watchhi[i] &

arch/mips/kernel/ptrace.c

200

child->thread.watch.mips3264.watchlo[i] = lt[i];

arch/mips/kernel/ptrace.c

202

child->thread.watch.mips3264.watchhi[i] = ht[i];

arch/mips/kernel/watch.c

20

struct mips3264_watch_reg_state *watches = &t->thread.watch.mips3264;

arch/mips/kernel/watch.c

53

&current->thread.watch.mips3264;

drivers/block/xen-blkback/xenbus.c

696

static void backend_changed(struct xenbus_watch *watch,

drivers/block/xen-blkback/xenbus.c

703

= container_of(watch, struct backend_info, backend_watch);

drivers/counter/104-quad-8.c

558

const struct counter_watch *watch)

drivers/counter/104-quad-8.c

562

if (watch->channel > QUAD8_NUM_COUNTERS - 1)

drivers/counter/104-quad-8.c

565

switch (watch->event) {

drivers/counter/104-quad-8.c

571

if (watch->channel == event_node->channel &&

drivers/counter/104-quad-8.c

572

watch->event != event_node->event)

drivers/counter/counter-chrdev.c

139

struct counter_watch *const watch,

drivers/counter/counter-chrdev.c

148

if (event_node->event == watch->event &&

drivers/counter/counter-chrdev.c

149

event_node->channel == watch->channel)

drivers/counter/counter-chrdev.c

160

event_node->event = watch->event;

drivers/counter/counter-chrdev.c

161

event_node->channel = watch->channel;

drivers/counter/counter-chrdev.c

268

struct counter_watch watch;

drivers/counter/counter-chrdev.c

276

if (copy_from_user(&watch, uwatch, sizeof(watch)))

drivers/counter/counter-chrdev.c

279

if (watch.component.type == COUNTER_COMPONENT_NONE)

drivers/counter/counter-chrdev.c

282

parent = watch.component.parent;

drivers/counter/counter-chrdev.c

285

switch (watch.component.scope) {

drivers/counter/counter-chrdev.c

314

id = watch.component.id;

drivers/counter/counter-chrdev.c

317

switch (watch.component.type) {

drivers/counter/counter-chrdev.c

319

if (watch.component.scope != COUNTER_SCOPE_SIGNAL)

drivers/counter/counter-chrdev.c

326

if (watch.component.scope != COUNTER_SCOPE_COUNT)

drivers/counter/counter-chrdev.c

333

if (watch.component.scope != COUNTER_SCOPE_COUNT)

drivers/counter/counter-chrdev.c

340

if (watch.component.scope != COUNTER_SCOPE_COUNT)

drivers/counter/counter-chrdev.c

367

err = counter->ops->watch_validate(counter, &watch);

drivers/counter/counter-chrdev.c

372

comp_node.component = watch.component;

drivers/counter/counter-chrdev.c

374

err = counter_set_event_node(counter, &watch, &comp_node);

drivers/counter/counter-chrdev.c

644

ev.watch.event = event;

drivers/counter/counter-chrdev.c

645

ev.watch.channel = channel;

drivers/counter/counter-chrdev.c

662

ev.watch.component = comp_node->component;

drivers/counter/interrupt-cnt.c

150

const struct counter_watch *watch)

drivers/counter/interrupt-cnt.c

152

if (watch->channel != 0 ||

drivers/counter/interrupt-cnt.c

153

watch->event != COUNTER_EVENT_CHANGE_OF_STATE)

drivers/counter/microchip-tcb-capture.c

341

const struct counter_watch *watch)

drivers/counter/microchip-tcb-capture.c

343

if (watch->channel == COUNTER_MCHP_EVCHN_CV || watch->channel == COUNTER_MCHP_EVCHN_RA)

drivers/counter/microchip-tcb-capture.c

344

switch (watch->event) {

drivers/counter/microchip-tcb-capture.c

353

if (watch->channel == COUNTER_MCHP_EVCHN_RB && watch->event == COUNTER_EVENT_CAPTURE)

drivers/counter/microchip-tcb-capture.c

356

if (watch->channel == COUNTER_MCHP_EVCHN_RC && watch->event == COUNTER_EVENT_THRESHOLD)

drivers/counter/stm32-timer-cnt.c

498

const struct counter_watch *watch)

drivers/counter/stm32-timer-cnt.c

506

switch (watch->event) {

drivers/counter/stm32-timer-cnt.c

508

if (watch->channel >= priv->nchannels) {

drivers/counter/stm32-timer-cnt.c

509

dev_err(counter->parent, "Invalid channel %d\n", watch->channel);

drivers/counter/ti-ecap-capture.c

211

const struct counter_watch *watch)

drivers/counter/ti-ecap-capture.c

213

if (watch->channel > ECAP_CEVT_LAST)

drivers/counter/ti-ecap-capture.c

216

switch (watch->event) {

drivers/counter/ti-eqep.c

308

const struct counter_watch *watch)

drivers/counter/ti-eqep.c

310

switch (watch->event) {

drivers/counter/ti-eqep.c

314

if (watch->channel != 0)

drivers/gpio/gpiolib-cdev.c

2343

bool watch)

drivers/gpio/gpiolib-cdev.c

2357

if (watch) {

drivers/gpio/gpiolib-cdev.c

2369

if (watch)

drivers/gpio/gpiolib-cdev.c

2379

bool watch)

drivers/gpio/gpiolib-cdev.c

2394

if (watch) {

drivers/gpio/gpiolib-cdev.c

2405

if (watch)

drivers/net/xen-netback/xenbus.c

523

static void xen_net_rate_changed(struct xenbus_watch *watch,

drivers/net/xen-netback/xenbus.c

526

struct xenvif *vif = container_of(watch, struct xenvif, credit_watch);

drivers/net/xen-netback/xenbus.c

582

static void xen_mcast_ctrl_changed(struct xenbus_watch *watch,

drivers/net/xen-netback/xenbus.c

585

struct xenvif *vif = container_of(watch, struct xenvif,

drivers/net/xen-netback/xenbus.c

659

static void hotplug_status_changed(struct xenbus_watch *watch,

drivers/net/xen-netback/xenbus.c

663

struct backend_info *be = container_of(watch,

drivers/xen/cpu_hotplug.c

72

static void handle_vcpu_hotplug_event(struct xenbus_watch *watch,

drivers/xen/manage.c

224

static void shutdown_handler(struct xenbus_watch *watch,

drivers/xen/manage.c

273

static void sysrq_handler(struct xenbus_watch *watch, const char *path,

drivers/xen/xen-balloon.c

63

static void watch_target(struct xenbus_watch *watch,

drivers/xen/xen-pciback/xenbus.c

659

static void xen_pcibk_be_watch(struct xenbus_watch *watch,

drivers/xen/xen-pciback/xenbus.c

663

container_of(watch, struct xen_pcibk_device, be_watch);

drivers/xen/xenbus/xenbus.h

127

void xenbus_otherend_changed(struct xenbus_watch *watch,

drivers/xen/xenbus/xenbus.h

47

bool (*otherend_will_handle)(struct xenbus_watch *watch,

drivers/xen/xenbus/xenbus.h

49

void (*otherend_changed)(struct xenbus_watch *watch, const char *path,

drivers/xen/xenbus/xenbus_client.c

132

struct xenbus_watch *watch,

drivers/xen/xenbus/xenbus_client.c

140

watch->node = path;

drivers/xen/xenbus/xenbus_client.c

141

watch->will_handle = will_handle;

drivers/xen/xenbus/xenbus_client.c

142

watch->callback = callback;

drivers/xen/xenbus/xenbus_client.c

144

err = register_xenbus_watch(watch);

drivers/xen/xenbus/xenbus_client.c

147

watch->node = NULL;

drivers/xen/xenbus/xenbus_client.c

148

watch->will_handle = NULL;

drivers/xen/xenbus/xenbus_client.c

149

watch->callback = NULL;

drivers/xen/xenbus/xenbus_client.c

178

struct xenbus_watch *watch,

drivers/xen/xenbus/xenbus_client.c

197

err = xenbus_watch_path(dev, path, watch, will_handle, callback);

drivers/xen/xenbus/xenbus_comms.c

212

struct xs_watch_event *watch;

drivers/xen/xenbus/xenbus_comms.c

262

len += sizeof(*state.watch);

drivers/xen/xenbus/xenbus_comms.c

269

state.body = state.watch->body;

drivers/xen/xenbus/xenbus_comms.c

287

state.watch->len = state.msg.len;

drivers/xen/xenbus/xenbus_comms.c

288

err = xs_watch_msg(state.watch);

drivers/xen/xenbus/xenbus_dev_frontend.c

228

struct xenbus_watch watch;

drivers/xen/xenbus/xenbus_dev_frontend.c

233

static void free_watch_adapter(struct watch_adapter *watch)

drivers/xen/xenbus/xenbus_dev_frontend.c

235

kfree(watch->watch.node);

drivers/xen/xenbus/xenbus_dev_frontend.c

236

kfree(watch->token);

drivers/xen/xenbus/xenbus_dev_frontend.c

237

kfree(watch);

drivers/xen/xenbus/xenbus_dev_frontend.c

243

struct watch_adapter *watch;

drivers/xen/xenbus/xenbus_dev_frontend.c

245

watch = kzalloc_obj(*watch);

drivers/xen/xenbus/xenbus_dev_frontend.c

246

if (watch == NULL)

drivers/xen/xenbus/xenbus_dev_frontend.c

249

watch->watch.node = kstrdup(path, GFP_KERNEL);

drivers/xen/xenbus/xenbus_dev_frontend.c

250

if (watch->watch.node == NULL)

drivers/xen/xenbus/xenbus_dev_frontend.c

253

watch->token = kstrdup(token, GFP_KERNEL);

drivers/xen/xenbus/xenbus_dev_frontend.c

254

if (watch->token == NULL)

drivers/xen/xenbus/xenbus_dev_frontend.c

257

return watch;

drivers/xen/xenbus/xenbus_dev_frontend.c

260

free_watch_adapter(watch);

drivers/xen/xenbus/xenbus_dev_frontend.c

266

static void watch_fired(struct xenbus_watch *watch,

drivers/xen/xenbus/xenbus_dev_frontend.c

277

adap = container_of(watch, struct watch_adapter, watch);

drivers/xen/xenbus/xenbus_dev_frontend.c

310

struct watch_adapter *watch, *tmp_watch;

drivers/xen/xenbus/xenbus_dev_frontend.c

326

list_for_each_entry_safe(watch, tmp_watch, &u->watches, list) {

drivers/xen/xenbus/xenbus_dev_frontend.c

327

unregister_xenbus_watch(&watch->watch);

drivers/xen/xenbus/xenbus_dev_frontend.c

328

list_del(&watch->list);

drivers/xen/xenbus/xenbus_dev_frontend.c

329

free_watch_adapter(watch);

drivers/xen/xenbus/xenbus_dev_frontend.c

498

struct watch_adapter *watch;

drivers/xen/xenbus/xenbus_dev_frontend.c

515

watch = alloc_watch_adapter(path, token);

drivers/xen/xenbus/xenbus_dev_frontend.c

516

if (watch == NULL) {

drivers/xen/xenbus/xenbus_dev_frontend.c

521

watch->watch.callback = watch_fired;

drivers/xen/xenbus/xenbus_dev_frontend.c

522

watch->dev_data = u;

drivers/xen/xenbus/xenbus_dev_frontend.c

524

err = register_xenbus_watch(&watch->watch);

drivers/xen/xenbus/xenbus_dev_frontend.c

526

free_watch_adapter(watch);

drivers/xen/xenbus/xenbus_dev_frontend.c

530

list_add(&watch->list, &u->watches);

drivers/xen/xenbus/xenbus_dev_frontend.c

532

list_for_each_entry(watch, &u->watches, list) {

drivers/xen/xenbus/xenbus_dev_frontend.c

533

if (!strcmp(watch->token, token) &&

drivers/xen/xenbus/xenbus_dev_frontend.c

534

!strcmp(watch->watch.node, path)) {

drivers/xen/xenbus/xenbus_dev_frontend.c

535

unregister_xenbus_watch(&watch->watch);

drivers/xen/xenbus/xenbus_dev_frontend.c

536

list_del(&watch->list);

drivers/xen/xenbus/xenbus_dev_frontend.c

537

free_watch_adapter(watch);

drivers/xen/xenbus/xenbus_probe.c

177

void xenbus_otherend_changed(struct xenbus_watch *watch,

drivers/xen/xenbus/xenbus_probe.c

182

container_of(watch, struct xenbus_device, otherend_watch);

drivers/xen/xenbus/xenbus_probe_backend.c

183

static bool frontend_will_handle(struct xenbus_watch *watch,

drivers/xen/xenbus/xenbus_probe_backend.c

186

return watch->nr_pending == 0;

drivers/xen/xenbus/xenbus_probe_backend.c

189

static void frontend_changed(struct xenbus_watch *watch,

drivers/xen/xenbus/xenbus_probe_backend.c

192

xenbus_otherend_changed(watch, path, token, 0);

drivers/xen/xenbus/xenbus_probe_backend.c

212

static void backend_changed(struct xenbus_watch *watch,

drivers/xen/xenbus/xenbus_probe_frontend.c

175

static void frontend_changed(struct xenbus_watch *watch,

drivers/xen/xenbus/xenbus_probe_frontend.c

88

static void backend_changed(struct xenbus_watch *watch,

drivers/xen/xenbus/xenbus_probe_frontend.c

91

xenbus_otherend_changed(watch, path, token, 1);

drivers/xen/xenbus/xenbus_xs.c

732

int register_xenbus_watch(struct xenbus_watch *watch)

drivers/xen/xenbus/xenbus_xs.c

735

char token[sizeof(watch) * 2 + 1];

drivers/xen/xenbus/xenbus_xs.c

738

sprintf(token, "%lX", (long)watch);

drivers/xen/xenbus/xenbus_xs.c

740

watch->nr_pending = 0;

drivers/xen/xenbus/xenbus_xs.c

746

list_add(&watch->list, &watches);

drivers/xen/xenbus/xenbus_xs.c

749

err = xs_watch(watch->node, token);

drivers/xen/xenbus/xenbus_xs.c

753

list_del(&watch->list);

drivers/xen/xenbus/xenbus_xs.c

763

void unregister_xenbus_watch(struct xenbus_watch *watch)

drivers/xen/xenbus/xenbus_xs.c

766

char token[sizeof(watch) * 2 + 1];

drivers/xen/xenbus/xenbus_xs.c

769

sprintf(token, "%lX", (long)watch);

drivers/xen/xenbus/xenbus_xs.c

775

list_del(&watch->list);

drivers/xen/xenbus/xenbus_xs.c

778

err = xs_unwatch(watch->node, token);

drivers/xen/xenbus/xenbus_xs.c

780

pr_warn("Failed to release watch %s: %i\n", watch->node, err);

drivers/xen/xenbus/xenbus_xs.c

791

if (watch->nr_pending) {

drivers/xen/xenbus/xenbus_xs.c

793

if (event->handle != watch)

drivers/xen/xenbus/xenbus_xs.c

798

watch->nr_pending = 0;

drivers/xen/xenbus/xenbus_xs.c

817

struct xenbus_watch *watch;

drivers/xen/xenbus/xenbus_xs.c

818

char token[sizeof(watch) * 2 + 1];

drivers/xen/xenbus/xenbus_xs.c

827

list_for_each_entry(watch, &watches, list) {

drivers/xen/xenbus/xenbus_xs.c

828

sprintf(token, "%lX", (long)watch);

drivers/xen/xenbus/xenbus_xs.c

829

xs_watch(watch->node, token);

include/linux/audit.h

54

struct audit_watch *watch; /* associated watch */

include/linux/ceph/osd_client.h

178

} watch;

include/linux/ceph/rados.h

522

} __attribute__ ((packed)) watch;

include/linux/counter.h

349

const struct counter_watch *watch);

include/linux/security.h

67

struct watch;

include/linux/watch_queue.h

75

void (*release_watch)(struct watch *);

include/linux/watch_queue.h

85

extern void init_watch(struct watch *, struct watch_queue *);

include/linux/watch_queue.h

86

extern int add_watch_to_object(struct watch *, struct watch_list *);

include/linux/watch_queue.h

95

void (*release_watch)(struct watch *))

include/uapi/linux/counter.h

116

struct counter_watch watch;

include/uapi/linux/watch_queue.h

75

struct watch_notification watch;

include/uapi/linux/watch_queue.h

99

struct watch_notification watch;

include/xen/xenbus.h

187

int register_xenbus_watch(struct xenbus_watch *watch);

include/xen/xenbus.h

188

void unregister_xenbus_watch(struct xenbus_watch *watch);

include/xen/xenbus.h

206

struct xenbus_watch *watch,

include/xen/xenbus.h

212

int xenbus_watch_pathfmt(struct xenbus_device *dev, struct xenbus_watch *watch,

kernel/audit.h

273

extern void audit_put_watch(struct audit_watch *watch);

kernel/audit.h

274

extern void audit_get_watch(struct audit_watch *watch);

kernel/audit.h

279

extern char *audit_watch_path(struct audit_watch *watch);

kernel/audit.h

280

extern int audit_watch_compare(struct audit_watch *watch, unsigned long ino,

kernel/audit_tree.c

732

rule->inode_f || rule->watch || rule->tree)

kernel/audit_watch.c

100

void audit_get_watch(struct audit_watch *watch)

kernel/audit_watch.c

102

refcount_inc(&watch->count);

kernel/audit_watch.c

105

void audit_put_watch(struct audit_watch *watch)

kernel/audit_watch.c

107

if (refcount_dec_and_test(&watch->count)) {

kernel/audit_watch.c

108

WARN_ON(watch->parent);

kernel/audit_watch.c

109

WARN_ON(!list_empty(&watch->rules));

kernel/audit_watch.c

110

kfree(watch->path);

kernel/audit_watch.c

111

kfree(watch);

kernel/audit_watch.c

115

static void audit_remove_watch(struct audit_watch *watch)

kernel/audit_watch.c

117

list_del(&watch->wlist);

kernel/audit_watch.c

118

audit_put_parent(watch->parent);

kernel/audit_watch.c

119

watch->parent = NULL;

kernel/audit_watch.c

120

audit_put_watch(watch); /* match initial get */

kernel/audit_watch.c

123

char *audit_watch_path(struct audit_watch *watch)

kernel/audit_watch.c

125

return watch->path;

kernel/audit_watch.c

128

int audit_watch_compare(struct audit_watch *watch, unsigned long ino, dev_t dev)

kernel/audit_watch.c

130

return (watch->ino != AUDIT_INO_UNSET) &&

kernel/audit_watch.c

131

(watch->ino == ino) &&

kernel/audit_watch.c

132

(watch->dev == dev);

kernel/audit_watch.c

162

struct audit_watch *watch;

kernel/audit_watch.c

164

watch = kzalloc_obj(*watch);

kernel/audit_watch.c

165

if (unlikely(!watch))

kernel/audit_watch.c

168

INIT_LIST_HEAD(&watch->rules);

kernel/audit_watch.c

169

refcount_set(&watch->count, 1);

kernel/audit_watch.c

170

watch->path = path;

kernel/audit_watch.c

171

watch->dev = AUDIT_DEV_UNSET;

kernel/audit_watch.c

172

watch->ino = AUDIT_INO_UNSET;

kernel/audit_watch.c

174

return watch;

kernel/audit_watch.c

180

struct audit_watch *watch;

kernel/audit_watch.c

189

krule->inode_f || krule->watch || krule->tree)

kernel/audit_watch.c

192

watch = audit_init_watch(path);

kernel/audit_watch.c

193

if (IS_ERR(watch))

kernel/audit_watch.c

194

return PTR_ERR(watch);

kernel/audit_watch.c

196

krule->watch = watch;

kernel/audit_watch.c

295

audit_put_watch(nentry->rule.watch);

kernel/audit_watch.c

297

nentry->rule.watch = nwatch;

kernel/audit_watch.c

348

static int audit_get_nd(struct audit_watch *watch, struct path *parent)

kernel/audit_watch.c

352

d = kern_path_parent(watch->path, parent);

kernel/audit_watch.c

358

watch->dev = d->d_sb->s_dev;

kernel/audit_watch.c

359

watch->ino = d_backing_inode(d)->i_ino;

kernel/audit_watch.c

371

struct audit_watch *w, *watch = krule->watch;

kernel/audit_watch.c

377

if (strcmp(watch->path, w->path))

kernel/audit_watch.c

383

audit_put_watch(watch);

kernel/audit_watch.c

386

krule->watch = watch = w;

kernel/audit_watch.c

393

watch->parent = parent;

kernel/audit_watch.c

395

audit_get_watch(watch);

kernel/audit_watch.c

396

list_add(&watch->wlist, &parent->watches);

kernel/audit_watch.c

398

list_add(&krule->rlist, &watch->rules);

kernel/audit_watch.c

405

struct audit_watch *watch = krule->watch;

kernel/audit_watch.c

415

audit_get_watch(watch);

kernel/audit_watch.c

420

ret = audit_get_nd(watch, &parent_path);

kernel/audit_watch.c

426

audit_put_watch(watch);

kernel/audit_watch.c

442

h = audit_hash_ino((u32)watch->ino);

kernel/audit_watch.c

446

audit_put_watch(watch);

kernel/audit_watch.c

452

struct audit_watch *watch = krule->watch;

kernel/audit_watch.c

453

struct audit_parent *parent = watch->parent;

kernel/audit_watch.c

457

if (list_empty(&watch->rules)) {

kernel/audit_watch.c

463

audit_remove_watch(watch);

kernel/auditfilter.c

1048

if (e->rule.watch)

kernel/auditfilter.c

1426

if (r->watch)

kernel/auditfilter.c

1431

if (r->watch || r->tree)

kernel/auditfilter.c

158

krule->inode_f || krule->watch || krule->tree ||

kernel/auditfilter.c

671

audit_watch_path(krule->watch));

kernel/auditfilter.c

736

if (strcmp(audit_watch_path(a->watch),

kernel/auditfilter.c

737

audit_watch_path(b->watch)))

kernel/auditfilter.c

89

if (erule->watch)

kernel/auditfilter.c

890

if (old->watch) {

kernel/auditfilter.c

891

audit_get_watch(old->watch);

kernel/auditfilter.c

892

new->watch = old->watch;

kernel/auditfilter.c

90

audit_put_watch(erule->watch);

kernel/auditfilter.c

910

} else if (entry->rule.watch) {

kernel/auditfilter.c

942

struct audit_watch *watch = entry->rule.watch;

kernel/auditfilter.c

969

if (watch) {

kernel/auditsc.c

634

result = audit_watch_compare(rule->watch,

kernel/watch_queue.c

200

struct watch *watch;

kernel/watch_queue.c

209

hlist_for_each_entry_rcu(watch, &wlist->watchers, list_node) {

kernel/watch_queue.c

210

if (watch->id != id)

kernel/watch_queue.c

213

n->info |= watch->info_id;

kernel/watch_queue.c

215

wqueue = rcu_dereference(watch->queue);

kernel/watch_queue.c

220

if (security_post_notification(watch->cred, cred, n) < 0)

kernel/watch_queue.c

424

struct watch *watch = container_of(rcu, struct watch, rcu);

kernel/watch_queue.c

426

put_watch_queue(rcu_access_pointer(watch->queue));

kernel/watch_queue.c

427

atomic_dec(&watch->cred->user->nr_watches);

kernel/watch_queue.c

428

put_cred(watch->cred);

kernel/watch_queue.c

429

kfree(watch);

kernel/watch_queue.c

434

struct watch *watch = container_of(kref, struct watch, usage);

kernel/watch_queue.c

436

call_rcu(&watch->rcu, free_watch);

kernel/watch_queue.c

442

static void put_watch(struct watch *watch)

kernel/watch_queue.c

444

kref_put(&watch->usage, __put_watch);

kernel/watch_queue.c

454

void init_watch(struct watch *watch, struct watch_queue *wqueue)

kernel/watch_queue.c

456

kref_init(&watch->usage);

kernel/watch_queue.c

457

INIT_HLIST_NODE(&watch->list_node);

kernel/watch_queue.c

458

INIT_HLIST_NODE(&watch->queue_node);

kernel/watch_queue.c

459

rcu_assign_pointer(watch->queue, wqueue);

kernel/watch_queue.c

462

static int add_one_watch(struct watch *watch, struct watch_list *wlist, struct watch_queue *wqueue)

kernel/watch_queue.c

465

struct watch *w;

kernel/watch_queue.c

469

if (wqueue == wq && watch->id == w->id)

kernel/watch_queue.c

479

watch->cred = get_cred(cred);

kernel/watch_queue.c

480

rcu_assign_pointer(watch->watch_list, wlist);

kernel/watch_queue.c

483

kref_get(&watch->usage);

kernel/watch_queue.c

484

hlist_add_head(&watch->queue_node, &wqueue->watches);

kernel/watch_queue.c

485

hlist_add_head_rcu(&watch->list_node, &wlist->watchers);

kernel/watch_queue.c

501

int add_watch_to_object(struct watch *watch, struct watch_list *wlist)

kernel/watch_queue.c

508

wqueue = rcu_access_pointer(watch->queue);

kernel/watch_queue.c

511

ret = add_one_watch(watch, wlist, wqueue);

kernel/watch_queue.c

536

struct watch *watch;

kernel/watch_queue.c

543

hlist_for_each_entry(watch, &wlist->watchers, list_node) {

kernel/watch_queue.c

545

(watch->id == id && rcu_access_pointer(watch->queue) == wq))

kernel/watch_queue.c

553

hlist_del_init_rcu(&watch->list_node);

kernel/watch_queue.c

554

rcu_assign_pointer(watch->watch_list, NULL);

kernel/watch_queue.c

559

n.watch.type = WATCH_TYPE_META;

kernel/watch_queue.c

560

n.watch.subtype = WATCH_META_REMOVAL_NOTIFICATION;

kernel/watch_queue.c

561

n.watch.info = watch->info_id | watch_sizeof(n.watch);

kernel/watch_queue.c

564

n.watch.info = watch->info_id | watch_sizeof(n);

kernel/watch_queue.c

566

wqueue = rcu_dereference(watch->queue);

kernel/watch_queue.c

569

post_one_notification(wqueue, &n.watch);

kernel/watch_queue.c

571

if (!hlist_unhashed(&watch->queue_node)) {

kernel/watch_queue.c

572

hlist_del_init_rcu(&watch->queue_node);

kernel/watch_queue.c

573

put_watch(watch);

kernel/watch_queue.c

580

void (*release_watch)(struct watch *);

kernel/watch_queue.c

584

(*release_watch)(watch);

kernel/watch_queue.c

587

put_watch(watch);

kernel/watch_queue.c

605

struct watch *watch;

kernel/watch_queue.c

618

watch = hlist_entry(wqueue->watches.first, struct watch, queue_node);

kernel/watch_queue.c

619

hlist_del_init_rcu(&watch->queue_node);

kernel/watch_queue.c

628

wlist = rcu_dereference(watch->watch_list);

kernel/watch_queue.c

630

void (*release_watch)(struct watch *);

kernel/watch_queue.c

634

release = !hlist_unhashed(&watch->list_node);

kernel/watch_queue.c

636

hlist_del_init_rcu(&watch->list_node);

kernel/watch_queue.c

637

rcu_assign_pointer(watch->watch_list, NULL);

kernel/watch_queue.c

651

(*release_watch)(watch);

kernel/watch_queue.c

654

put_watch(watch);

kernel/watch_queue.c

658

put_watch(watch);

net/ceph/debugfs.c

231

ceph_osd_watch_op_name(op->watch.op));

net/ceph/osd_client.c

3152

req->r_ops[0].watch.gen);

net/ceph/osd_client.c

3197

if (lreq->register_gen == req->r_ops[0].watch.gen) {

net/ceph/osd_client.c

3206

lreq->register_gen, req->r_ops[0].watch.gen);

net/ceph/osd_client.c

894

op->watch.cookie = cookie;

net/ceph/osd_client.c

895

op->watch.op = watch_opcode;

net/ceph/osd_client.c

896

op->watch.gen = gen;

net/ceph/osd_client.c

991

dst->watch.cookie = cpu_to_le64(src->watch.cookie);

net/ceph/osd_client.c

992

dst->watch.ver = cpu_to_le64(0);

net/ceph/osd_client.c

993

dst->watch.op = src->watch.op;

net/ceph/osd_client.c

994

dst->watch.gen = cpu_to_le32(src->watch.gen);

security/keys/internal.h

184

.watch.type = WATCH_TYPE_KEY_NOTIFY,

security/keys/internal.h

185

.watch.subtype = subtype,

security/keys/internal.h

186

.watch.info = watch_sizeof(n),

security/keys/internal.h

191

post_watch_notification(key->watchers, &n.watch, current_cred(),

security/keys/keyctl.c

1777

struct watch *watch = NULL;

security/keys/keyctl.c

1805

watch = kzalloc_obj(*watch);

security/keys/keyctl.c

1806

if (!watch)

security/keys/keyctl.c

1809

init_watch(watch, wqueue);

security/keys/keyctl.c

1810

watch->id = key->serial;

security/keys/keyctl.c

1811

watch->info_id = (u32)watch_id << WATCH_INFO_ID__SHIFT;

security/keys/keyctl.c

1823

ret = add_watch_to_object(watch, key->watchers);

security/keys/keyctl.c

1827

watch = NULL;

security/keys/keyctl.c

1840

kfree(watch);

tools/counter/counter_watch_events.c

395

counter_event_type_name[event_data.watch.event],

tools/counter/counter_watch_events.c

396

event_data.watch.channel);

tools/counter/counter_watch_events.c

59

static void print_watch(struct counter_watch *watch, int nwatch)

tools/counter/counter_watch_events.c

75

counter_component_type_name[watch[i].component.type],

tools/counter/counter_watch_events.c

76

counter_scope_name[watch[i].component.scope],

tools/counter/counter_watch_events.c

77

watch[i].component.parent,

tools/counter/counter_watch_events.c

78

watch[i].component.id,

tools/counter/counter_watch_events.c

79

counter_event_type_name[watch[i].event],

tools/counter/counter_watch_events.c

80

watch[i].channel);