Re: using poll on /proc/mdstat

On Sat, 25 Dec 2010 10:49:02 +0800 "kernel.majianpeng"
wrote:

>
>
> According md.c:
> * We have a system wide 'event count' that is incremented
> * on any 'interesting' event, and readers of /proc/mdstat
> * can use 'poll' or 'select' to find out when the event
> * count increases.
> Events are:
> * start array, stop array, error, add device, remove device,
> * start build, activate spare
> I wanted to monitor RAID5 events,so I writed a c-function:
> int fd = open("/proc/mdstat",O_RDONLY);
> if(fd < 0){
> printf("open /proc/mdstat error:%s\n",strerror(errno));
> return -errno;
> }
> struct pollfd fds[1];
> int ret;
> fds[0].fd = fd;
> fds[0].events = POLLPRI;
> while(1){
> fds[0].fd = fd;
> fds[0].events = POLLPRI;
> ret = poll(fds,1,-1);
> if(ret < 0){
> printf("poll error:%s\n",strerror(errno));
> break;
> }else
> printf("ret value=%d\n",ret);
> }
> close(fd);
> But this function did not run like my thought.
> After a raid event occured,the poll did not blocked,.The function only well at first.

poll will only block again after you read to the end of the file (and thus
observe any change), and then seek back to the start.

Any time that poll reports and event, you need to respond to that event (e.g.
by reading) or poll will continue to tell you that the event is pending.
This helps avoid some races.


> I wrote anthoer function:
> do{
> int fd = open("/proc/mdstat",O_RDONLY);
> if(fd < 0){
> printf("open /proc/mdstat error:%s\n",strerror(errno));
> return ;
> }
> struct pollfd fds;
> memset(&fds,0, sizeof(struct pollfd));
> fds.fd = fd;
> fds.events = POLLPRI|POLLERR;
> if(poll(&fds,1,-1) == -1){
> printf("poll error:%s\n",strerror(errno));
> break;
> }
> printf("return events:%d\n",fds.revents);
> close(fd);
> }while(1);
> this function work well, can return when raid_event occured.

After each poll, you close and re-open the file. This is enough to 'tell'
poll that you have noticed the event.

If you have further questions, please ask.

NeilBrown



> I read the source found:
> static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
> {
> struct seq_file *m = filp->private_data;
> struct mdstat_info *mi = m->private;
> int mask;
> poll_wait(filp, &md_event_waiters, wait);
> /* always allow read */
> mask = POLLIN | POLLRDNORM;
> if (mi->event != atomic_read(&md_event_count)){
> mask |= POLLERR | POLLPRI;
> }
> return mask;
> }
> the mi->event assigned at function:md_seq_open.
> When open /proc/mdstat,the mi->event = md_event_count, so the first poll blocked.
> But after poll return,mi->event != md_event_count,so the rest poll must immediately return.
> In second function,every time I opend /proc/mdstat,so mi->event = md_event_count, when blocked
>
> 2010-12-25
>
>
>
> kernel.majianpeng
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-raid" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html

--
To unsubscribe from this list: send the line "unsubscribe linux-raid" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html

Re: Re: using poll on /proc/mdstat

SGkgYWxsOg0KICAgIHJlYWQgTmVpbCBCcm93bidzIG1haWwsIEkgbW9kaWZp ZWQgdGhlIGZ1bmN0
aW9uOg0KY2hhciBidWZmWzQwOTZdID0gezB9Ow0KCWludCBmZCA9IG9wZW4o Ii9wcm9jL21kc3Rh
dCIsT19SRE9OTFkpOw0KCWlmKGZkIDwgMCl7DQoJCXByaW50Zigib3BlbiAv cHJvYy9tZHN0YXQg
ZXJyb3I6JXNcbiIsc3RyZXJyb3IoZXJybm8pKTsNCgkJcmV0dXJuIC1lcnJu bzsNCgl9DQoNCglz
dHJ1Y3QgcG9sbGZkIGZkc1sxXTsNCglpbnQgcmV0Ow0KDQoJZmRzWzBdLmZk ID0gZmQ7DQoJZmRz
WzBdLmV2ZW50cyA9IFBPTExQUkk7DQoJd2hpbGUoMSl7DQoJCWZkc1swXS5m ZCA9IGZkOw0KCQlm
ZHNbMF0uZXZlbnRzID0gUE9MTFBSSTsNCgkJcmV0ID0gcG9sbChmZHMsMSwt MSk7DQoJCWlmKHJl
dCA8IDApew0KCQkJcHJpbnRmKCJwb2xsIGVycm9yOiVzXG4iLHN0cmVycm9y KGVycm5vKSk7DQoJ
CQlicmVhazsNCgkJfWVsc2UNCgkJCXByaW50ZigicmV0IHZhbHVlPSVkXG4i LGZkc1swXS5yZXZl
bnRzKTsNCgkJcmVhZChmZCxidWZmLDQwOTYpOw0KCQltZW1zZXQoYnVmZiAs MCw0MDk2KTsNCgl9
DQoJY2xvc2UoZmQpOw0KDQpJIGFkZCByZWFkIGNvbW1hbmQgYW5kIGNvbmZp cm0gcmVhZCBlbmQg
b2YgZmlsZSAvcHJvYy9tZHN0YXQuDQpCdXQgdGhpcyBmdXRpb24gYWxzbyB0 byBmaW5kIG9ubHkg
b25lIGV2ZW50Lg0KDQotLS0tLS0tLS0tLS0tLS0tLS0JCQkJIA0Ka2VybmVs Lm1hamlhbnBlbmcN
CjIwMTAtMTItMjcNCg0KLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLQ0Kt6K8/sjLo7pOZWlsIEJyb3duDQq3osvN yNXG2qO6MjAxMC0x
Mi0yNiAxOTo0NDo0Mw0KytW8/sjLo7prZXJuZWwubWFqaWFucGVuZw0Ks63L zaO6bGludXgtcmFp
ZA0K1vfM4qO6UmU6IHVzaW5nIHBvbGwgb24gL3Byb2MvbWRzdGF0DQoNCk9u IFNhdCwgMjUgRGVj
IDIwMTAgMTA6NDk6MDIgKzA4MDAgImtlcm5lbC5tYWppYW5wZW5nIg0KPGtl cm5lbC5tYWppYW5w
ZW5nQGdtYWlsLmNvbT4gd3JvdGU6DQoNCj4gDQo+IA0KPiBBY2NvcmRpbmcg bWQuYzoNCj4gICog
V2UgaGF2ZSBhIHN5c3RlbSB3aWRlICdldmVudCBjb3VudCcgdGhhdCBpcyBp bmNyZW1lbnRlZA0K
PiAgKiBvbiBhbnkgJ2ludGVyZXN0aW5nJyBldmVudCwgYW5kIHJlYWRlcnMg b2YgL3Byb2MvbWRz
dGF0DQo+ICAqIGNhbiB1c2UgJ3BvbGwnIG9yICdzZWxlY3QnIHRvIGZpbmQg b3V0IHdoZW4gdGhl
IGV2ZW50DQo+ICAqIGNvdW50IGluY3JlYXNlcy4NCj4gRXZlbnRzIGFyZToN Cj4gICogIHN0YXJ0
IGFycmF5LCBzdG9wIGFycmF5LCBlcnJvciwgYWRkIGRldmljZSwgcmVtb3Zl IGRldmljZSwNCj4g
ICogIHN0YXJ0IGJ1aWxkLCBhY3RpdmF0ZSBzcGFyZQ0KPiBJIHdhbnRlZCB0 byBtb25pdG9yIFJB
SUQ1IGV2ZW50cyxzbyBJIHdyaXRlZCBhIGMtZnVuY3Rpb246DQo+IGludCBm ZCA9IG9wZW4oIi9w
cm9jL21kc3RhdCIsT19SRE9OTFkpOw0KPiBpZihmZCA8IDApew0KPiBwcmlu dGYoIm9wZW4gL3By
b2MvbWRzdGF0IGVycm9yOiVzXG4iLHN0cmVycm9yKGVycm5vKSk7DQo+IHJl dHVybiAtZXJybm87
DQo+IH0NCj4gc3RydWN0IHBvbGxmZCBmZHNbMV07DQo+IGludCByZXQ7DQo+ IGZkc1swXS5mZCA9
IGZkOw0KPiBmZHNbMF0uZXZlbnRzID0gUE9MTFBSSTsNCj4gd2hpbGUoMSl7 DQo+IGZkc1swXS5m
ZCA9IGZkOw0KPiBmZHNbMF0uZXZlbnRzID0gUE9MTFBSSTsNCj4gcmV0ID0g cG9sbChmZHMsMSwt
MSk7DQo+IGlmKHJldCA8IDApew0KPiBwcmludGYoInBvbGwgZXJyb3I6JXNc biIsc3RyZXJyb3Io
ZXJybm8pKTsNCj4gYnJlYWs7DQo+IH1lbHNlDQo+IHByaW50ZigicmV0IHZh bHVlPSVkXG4iLHJl
dCk7DQo+IH0NCj4gY2xvc2UoZmQpOw0KPiBCdXQgdGhpcyBmdW5jdGlvbiAg ZGlkIG5vdCBydW4g
bGlrZSBteSB0aG91Z2h0Lg0KPiBBZnRlciBhIHJhaWQgZXZlbnQgb2NjdXJl ZCx0aGUgcG9sbCBk
aWQgbm90IGJsb2NrZWQsLlRoZSBmdW5jdGlvbiBvbmx5IHdlbGwgYXQgZmly c3QuDQoNCnBvbGwg
d2lsbCBvbmx5IGJsb2NrIGFnYWluIGFmdGVyIHlvdSByZWFkIHRvIHRoZSBl bmQgb2YgdGhlIGZp
bGUgKGFuZCB0aHVzDQpvYnNlcnZlIGFueSBjaGFuZ2UpLCBhbmQgdGhlbiBz ZWVrIGJhY2sgdG8g
dGhlIHN0YXJ0Lg0KDQpBbnkgdGltZSB0aGF0IHBvbGwgcmVwb3J0cyBhbmQg ZXZlbnQsIHlvdSBu
ZWVkIHRvIHJlc3BvbmQgdG8gdGhhdCBldmVudCAoZS5nLg0KYnkgcmVhZGlu Zykgb3IgcG9sbCB3
aWxsIGNvbnRpbnVlIHRvIHRlbGwgeW91IHRoYXQgdGhlIGV2ZW50IGlzIHBl bmRpbmcuDQpUaGlz
IGhlbHBzIGF2b2lkIHNvbWUgcmFjZXMuDQoNCg0KPiBJIHdyb3RlIGFudGhv ZXIgZnVuY3Rpb246
DQo+IGRvew0KPiBpbnQgZmQgPSBvcGVuKCIvcHJvYy9tZHN0YXQiLE9fUkRP TkxZKTsNCj4gaWYo
ZmQgPCAwKXsNCj4gcHJpbnRmKCJvcGVuIC9wcm9jL21kc3RhdCBlcnJvcjol c1xuIixzdHJlcnJv
cihlcnJubykpOw0KPiByZXR1cm4gOw0KPiB9DQo+IHN0cnVjdCBwb2xsZmQg ZmRzOw0KPiBtZW1z
ZXQoJmZkcywwLCBzaXplb2Yoc3RydWN0IHBvbGxmZCkpOw0KPiBmZHMuZmQg PSBmZDsNCj4gZmRz
LmV2ZW50cyA9IFBPTExQUkl8UE9MTEVSUjsNCj4gaWYocG9sbCgmZmRzLDEs LTEpID09IC0xKXsN
Cj4gcHJpbnRmKCJwb2xsIGVycm9yOiVzXG4iLHN0cmVycm9yKGVycm5vKSk7 DQo+IGJyZWFrOw0K
PiB9DQo+IHByaW50ZigicmV0dXJuIGV2ZW50czolZFxuIixmZHMucmV2ZW50 cyk7DQo+IGNsb3Nl
KGZkKTsNCj4gfXdoaWxlKDEpOw0KPiB0aGlzIGZ1bmN0aW9uIHdvcmsgd2Vs bCwgY2FuIHJldHVy
biB3aGVuIHJhaWRfZXZlbnQgb2NjdXJlZC4NCg0KQWZ0ZXIgZWFjaCBwb2xs LCB5b3UgY2xvc2Ug
YW5kIHJlLW9wZW4gdGhlIGZpbGUuICBUaGlzIGlzIGVub3VnaCB0byAndGVs bCcNCnBvbGwgdGhh
dCB5b3UgaGF2ZSBub3RpY2VkIHRoZSBldmVudC4NCg0KSWYgeW91IGhhdmUg ZnVydGhlciBxdWVz
dGlvbnMsIHBsZWFzZSBhc2suDQoNCk5laWxCcm93bg0KDQoNCg0KPiBJIHJl YWQgdGhlIHNvdXJj
ZSBmb3VuZDoNCj4gc3RhdGljIHVuc2lnbmVkIGludCBtZHN0YXRfcG9sbChz dHJ1Y3QgZmlsZSAq
ZmlscCwgcG9sbF90YWJsZSAqd2FpdCkNCj4gew0KPiBzdHJ1Y3Qgc2VxX2Zp bGUgKm0gPSBmaWxw
LT5wcml2YXRlX2RhdGE7DQo+IHN0cnVjdCBtZHN0YXRfaW5mbyAqbWkgPSBt LT5wcml2YXRlOw0K
PiBpbnQgbWFzazsNCj4gcG9sbF93YWl0KGZpbHAsICZtZF9ldmVudF93YWl0 ZXJzLCB3YWl0KTsN
Cj4gLyogYWx3YXlzIGFsbG93IHJlYWQgKi8NCj4gbWFzayA9IFBPTExJTiB8 IFBPTExSRE5PUk07
DQo+IGlmIChtaS0+ZXZlbnQgIT0gYXRvbWljX3JlYWQoJm1kX2V2ZW50X2Nv dW50KSl7DQo+IG1h
c2sgfD0gUE9MTEVSUiB8IFBPTExQUkk7DQo+IH0NCj4gcmV0dXJuIG1hc2s7 DQo+IH0NCj4gdGhl
IG1pLT5ldmVudCBhc3NpZ25lZCBhdCBmdW5jdGlvbjptZF9zZXFfb3Blbi4N Cj4gV2hlbiBvcGVu
IC9wcm9jL21kc3RhdCx0aGUgbWktPmV2ZW50ID0gbWRfZXZlbnRfY291bnQs IHNvIHRoZSBmaXJz
dCBwb2xsIGJsb2NrZWQuDQo+IEJ1dCBhZnRlciBwb2xsIHJldHVybixtaS0+ ZXZlbnQgIT0gbWRf
ZXZlbnRfY291bnQsc28gdGhlIHJlc3QgcG9sbCBtdXN0IGltbWVkaWF0ZWx5 IHJldHVybi4NCj4g
SW4gc2Vjb25kIGZ1bmN0aW9uLGV2ZXJ5IHRpbWUgSSBvcGVuZCAvcHJvYy9t ZHN0YXQsc28gbWkt
PmV2ZW50ID0gbWRfZXZlbnRfY291bnQsIHdoZW4gYmxvY2tlZA0KPiANCj4g MjAxMC0xMi0yNSAN
Cj4gDQo+IA0KPiANCj4ga2VybmVsLm1hamlhbnBlbmcgDQo+IA0KPiAtLQ0K PiBUbyB1bnN1YnNj
cmliZSBmcm9tIHRoaXMgbGlzdDogc2VuZCB0aGUgbGluZSAidW5zdWJzY3Jp YmUgbGludXgtcmFp
ZCIgaW4NCj4gdGhlIGJvZHkgb2YgYSBtZXNzYWdlIHRvIG1ham9yZG9tb0B2 Z2VyLmtlcm5lbC5v
cmcNCj4gTW9yZSBtYWpvcmRvbW8gaW5mbyBhdCAgaHR0cDovL3ZnZXIua2Vy bmVsLm9yZy9tYWpv
cmRvbW8taW5mby5odG1sDQo=

--
To unsubscribe from this list: send the line "unsubscribe linux-raid" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html