aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorIngo Molnar <mingo@elte.hu>2006-04-11 07:53:10 -0400
committerJens Axboe <axboe@suse.de>2006-04-11 07:53:10 -0400
commit9aeedfc4712ed58d9f7ae41596185c72b8dc97e8 (patch)
treeb055bab09a86cfc6cb13506d2f25da6abd12e3c1
parent7480a90435673b4c717b6caf1350ec577d5f1adf (diff)
[PATCH] get rid of the PIPE_*() macros
get rid of the PIPE_*() macros. Scripted transformation. Signed-off-by: Ingo Molnar <mingo@elte.hu> Signed-off-by: Jens Axboe <axboe@suse.de>
Diffstat
-rw-r--r--fs/fifo.c48
-rw-r--r--fs/pipe.c104
-rw-r--r--include/linux/pipe_fs_i.h10
3 files changed, 76 insertions, 86 deletions
diff --git a/fs/fifo.c b/fs/fifo.c
index b16e2f597d61..2c27f56d7304 100644
--- a/fs/fifo.c
+++ b/fs/fifo.c
@@ -28,14 +28,14 @@ static void wait_for_partner(struct inode* inode, unsigned int *cnt)
28 28
29static void wake_up_partner(struct inode* inode) 29static void wake_up_partner(struct inode* inode)
30{ 30{
31 wake_up_interruptible(PIPE_WAIT(*inode)); 31 wake_up_interruptible(&inode->i_pipe->wait);
32} 32}
33 33
34static int fifo_open(struct inode *inode, struct file *filp) 34static int fifo_open(struct inode *inode, struct file *filp)
35{ 35{
36 int ret; 36 int ret;
37 37
38 mutex_lock(PIPE_MUTEX(*inode)); 38 mutex_lock(&inode->i_mutex);
39 if (!inode->i_pipe) { 39 if (!inode->i_pipe) {
40 ret = -ENOMEM; 40 ret = -ENOMEM;
41 inode->i_pipe = alloc_pipe_info(inode); 41 inode->i_pipe = alloc_pipe_info(inode);
@@ -55,18 +55,18 @@ static int fifo_open(struct inode *inode, struct file *filp)
55 * opened, even when there is no process writing the FIFO. 55 * opened, even when there is no process writing the FIFO.
56 */ 56 */
57 filp->f_op = &read_fifo_fops; 57 filp->f_op = &read_fifo_fops;
58 PIPE_RCOUNTER(*inode)++; 58 inode->i_pipe->r_counter++;
59 if (PIPE_READERS(*inode)++ == 0) 59 if (inode->i_pipe->readers++ == 0)
60 wake_up_partner(inode); 60 wake_up_partner(inode);
61 61
62 if (!PIPE_WRITERS(*inode)) { 62 if (!inode->i_pipe->writers) {
63 if ((filp->f_flags & O_NONBLOCK)) { 63 if ((filp->f_flags & O_NONBLOCK)) {
64 /* suppress POLLHUP until we have 64 /* suppress POLLHUP until we have
65 * seen a writer */ 65 * seen a writer */
66 filp->f_version = PIPE_WCOUNTER(*inode); 66 filp->f_version = inode->i_pipe->w_counter;
67 } else 67 } else
68 { 68 {
69 wait_for_partner(inode, &PIPE_WCOUNTER(*inode)); 69 wait_for_partner(inode, &inode->i_pipe->w_counter);
70 if(signal_pending(current)) 70 if(signal_pending(current))
71 goto err_rd; 71 goto err_rd;
72 } 72 }
@@ -80,16 +80,16 @@ static int fifo_open(struct inode *inode, struct file *filp)
80 * errno=ENXIO when there is no process reading the FIFO. 80 * errno=ENXIO when there is no process reading the FIFO.
81 */ 81 */
82 ret = -ENXIO; 82 ret = -ENXIO;
83 if ((filp->f_flags & O_NONBLOCK) && !PIPE_READERS(*inode)) 83 if ((filp->f_flags & O_NONBLOCK) && !inode->i_pipe->readers)
84 goto err; 84 goto err;
85 85
86 filp->f_op = &write_fifo_fops; 86 filp->f_op = &write_fifo_fops;
87 PIPE_WCOUNTER(*inode)++; 87 inode->i_pipe->w_counter++;
88 if (!PIPE_WRITERS(*inode)++) 88 if (!inode->i_pipe->writers++)
89 wake_up_partner(inode); 89 wake_up_partner(inode);
90 90
91 if (!PIPE_READERS(*inode)) { 91 if (!inode->i_pipe->readers) {
92 wait_for_partner(inode, &PIPE_RCOUNTER(*inode)); 92 wait_for_partner(inode, &inode->i_pipe->r_counter);
93 if (signal_pending(current)) 93 if (signal_pending(current))
94 goto err_wr; 94 goto err_wr;
95 } 95 }
@@ -104,11 +104,11 @@ static int fifo_open(struct inode *inode, struct file *filp)
104 */ 104 */
105 filp->f_op = &rdwr_fifo_fops; 105 filp->f_op = &rdwr_fifo_fops;
106 106
107 PIPE_READERS(*inode)++; 107 inode->i_pipe->readers++;
108 PIPE_WRITERS(*inode)++; 108 inode->i_pipe->writers++;
109 PIPE_RCOUNTER(*inode)++; 109 inode->i_pipe->r_counter++;
110 PIPE_WCOUNTER(*inode)++; 110 inode->i_pipe->w_counter++;
111 if (PIPE_READERS(*inode) == 1 || PIPE_WRITERS(*inode) == 1) 111 if (inode->i_pipe->readers == 1 || inode->i_pipe->writers == 1)
112 wake_up_partner(inode); 112 wake_up_partner(inode);
113 break; 113 break;
114 114
@@ -118,27 +118,27 @@ static int fifo_open(struct inode *inode, struct file *filp)
118 } 118 }
119 119
120 /* Ok! */ 120 /* Ok! */
121 mutex_unlock(PIPE_MUTEX(*inode)); 121 mutex_unlock(&inode->i_mutex);
122 return 0; 122 return 0;
123 123
124err_rd: 124err_rd:
125 if (!--PIPE_READERS(*inode)) 125 if (!--inode->i_pipe->readers)
126 wake_up_interruptible(PIPE_WAIT(*inode)); 126 wake_up_interruptible(&inode->i_pipe->wait);
127 ret = -ERESTARTSYS; 127 ret = -ERESTARTSYS;
128 goto err; 128 goto err;
129 129
130err_wr: 130err_wr:
131 if (!--PIPE_WRITERS(*inode)) 131 if (!--inode->i_pipe->writers)
132 wake_up_interruptible(PIPE_WAIT(*inode)); 132 wake_up_interruptible(&inode->i_pipe->wait);
133 ret = -ERESTARTSYS; 133 ret = -ERESTARTSYS;
134 goto err; 134 goto err;
135 135
136err: 136err:
137 if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode)) 137 if (!inode->i_pipe->readers && !inode->i_pipe->writers)
138 free_pipe_info(inode); 138 free_pipe_info(inode);
139 139
140err_nocleanup: 140err_nocleanup:
141 mutex_unlock(PIPE_MUTEX(*inode)); 141 mutex_unlock(&inode->i_mutex);
142 return ret; 142 return ret;
143} 143}
144 144
diff --git a/fs/pipe.c b/fs/pipe.c
index 036536f072c9..0602fc9f7eba 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -158,7 +158,7 @@ pipe_readv(struct file *filp, const struct iovec *_iov,
158 158
159 do_wakeup = 0; 159 do_wakeup = 0;
160 ret = 0; 160 ret = 0;
161 mutex_lock(PIPE_MUTEX(*inode)); 161 mutex_lock(&inode->i_mutex);
162 info = inode->i_pipe; 162 info = inode->i_pipe;
163 for (;;) { 163 for (;;) {
164 int bufs = info->nrbufs; 164 int bufs = info->nrbufs;
@@ -202,9 +202,9 @@ pipe_readv(struct file *filp, const struct iovec *_iov,
202 } 202 }
203 if (bufs) /* More to do? */ 203 if (bufs) /* More to do? */
204 continue; 204 continue;
205 if (!PIPE_WRITERS(*inode)) 205 if (!inode->i_pipe->writers)
206 break; 206 break;
207 if (!PIPE_WAITING_WRITERS(*inode)) { 207 if (!inode->i_pipe->waiting_writers) {
208 /* syscall merging: Usually we must not sleep 208 /* syscall merging: Usually we must not sleep
209 * if O_NONBLOCK is set, or if we got some data. 209 * if O_NONBLOCK is set, or if we got some data.
210 * But if a writer sleeps in kernel space, then 210 * But if a writer sleeps in kernel space, then
@@ -222,16 +222,16 @@ pipe_readv(struct file *filp, const struct iovec *_iov,
222 break; 222 break;
223 } 223 }
224 if (do_wakeup) { 224 if (do_wakeup) {
225 wake_up_interruptible_sync(PIPE_WAIT(*inode)); 225 wake_up_interruptible_sync(&inode->i_pipe->wait);
226 kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT); 226 kill_fasync(&inode->i_pipe->fasync_writers, SIGIO, POLL_OUT);
227 } 227 }
228 pipe_wait(inode->i_pipe); 228 pipe_wait(inode->i_pipe);
229 } 229 }
230 mutex_unlock(PIPE_MUTEX(*inode)); 230 mutex_unlock(&inode->i_mutex);
231 /* Signal writers asynchronously that there is more room. */ 231 /* Signal writers asynchronously that there is more room. */
232 if (do_wakeup) { 232 if (do_wakeup) {
233 wake_up_interruptible(PIPE_WAIT(*inode)); 233 wake_up_interruptible(&inode->i_pipe->wait);
234 kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT); 234 kill_fasync(&inode->i_pipe->fasync_writers, SIGIO, POLL_OUT);
235 } 235 }
236 if (ret > 0) 236 if (ret > 0)
237 file_accessed(filp); 237 file_accessed(filp);
@@ -264,10 +264,10 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
264 264
265 do_wakeup = 0; 265 do_wakeup = 0;
266 ret = 0; 266 ret = 0;
267 mutex_lock(PIPE_MUTEX(*inode)); 267 mutex_lock(&inode->i_mutex);
268 info = inode->i_pipe; 268 info = inode->i_pipe;
269 269
270 if (!PIPE_READERS(*inode)) { 270 if (!inode->i_pipe->readers) {
271 send_sig(SIGPIPE, current, 0); 271 send_sig(SIGPIPE, current, 0);
272 ret = -EPIPE; 272 ret = -EPIPE;
273 goto out; 273 goto out;
@@ -306,7 +306,7 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
306 306
307 for (;;) { 307 for (;;) {
308 int bufs; 308 int bufs;
309 if (!PIPE_READERS(*inode)) { 309 if (!inode->i_pipe->readers) {
310 send_sig(SIGPIPE, current, 0); 310 send_sig(SIGPIPE, current, 0);
311 if (!ret) ret = -EPIPE; 311 if (!ret) ret = -EPIPE;
312 break; 312 break;
@@ -367,19 +367,19 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
367 break; 367 break;
368 } 368 }
369 if (do_wakeup) { 369 if (do_wakeup) {
370 wake_up_interruptible_sync(PIPE_WAIT(*inode)); 370 wake_up_interruptible_sync(&inode->i_pipe->wait);
371 kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN); 371 kill_fasync(&inode->i_pipe->fasync_readers, SIGIO, POLL_IN);
372 do_wakeup = 0; 372 do_wakeup = 0;
373 } 373 }
374 PIPE_WAITING_WRITERS(*inode)++; 374 inode->i_pipe->waiting_writers++;
375 pipe_wait(inode->i_pipe); 375 pipe_wait(inode->i_pipe);
376 PIPE_WAITING_WRITERS(*inode)--; 376 inode->i_pipe->waiting_writers--;
377 } 377 }
378out: 378out:
379 mutex_unlock(PIPE_MUTEX(*inode)); 379 mutex_unlock(&inode->i_mutex);
380 if (do_wakeup) { 380 if (do_wakeup) {
381 wake_up_interruptible(PIPE_WAIT(*inode)); 381 wake_up_interruptible(&inode->i_pipe->wait);
382 kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN); 382 kill_fasync(&inode->i_pipe->fasync_readers, SIGIO, POLL_IN);
383 } 383 }
384 if (ret > 0) 384 if (ret > 0)
385 file_update_time(filp); 385 file_update_time(filp);
@@ -416,7 +416,7 @@ pipe_ioctl(struct inode *pino, struct file *filp,
416 416
417 switch (cmd) { 417 switch (cmd) {
418 case FIONREAD: 418 case FIONREAD:
419 mutex_lock(PIPE_MUTEX(*inode)); 419 mutex_lock(&inode->i_mutex);
420 info = inode->i_pipe; 420 info = inode->i_pipe;
421 count = 0; 421 count = 0;
422 buf = info->curbuf; 422 buf = info->curbuf;
@@ -425,7 +425,7 @@ pipe_ioctl(struct inode *pino, struct file *filp,
425 count += info->bufs[buf].len; 425 count += info->bufs[buf].len;
426 buf = (buf+1) & (PIPE_BUFFERS-1); 426 buf = (buf+1) & (PIPE_BUFFERS-1);
427 } 427 }
428 mutex_unlock(PIPE_MUTEX(*inode)); 428 mutex_unlock(&inode->i_mutex);
429 return put_user(count, (int __user *)arg); 429 return put_user(count, (int __user *)arg);
430 default: 430 default:
431 return -EINVAL; 431 return -EINVAL;
@@ -441,14 +441,14 @@ pipe_poll(struct file *filp, poll_table *wait)
441 struct pipe_inode_info *info = inode->i_pipe; 441 struct pipe_inode_info *info = inode->i_pipe;
442 int nrbufs; 442 int nrbufs;
443 443
444 poll_wait(filp, PIPE_WAIT(*inode), wait); 444 poll_wait(filp, &inode->i_pipe->wait, wait);
445 445
446 /* Reading only -- no need for acquiring the semaphore. */ 446 /* Reading only -- no need for acquiring the semaphore. */
447 nrbufs = info->nrbufs; 447 nrbufs = info->nrbufs;
448 mask = 0; 448 mask = 0;
449 if (filp->f_mode & FMODE_READ) { 449 if (filp->f_mode & FMODE_READ) {
450 mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0; 450 mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
451 if (!PIPE_WRITERS(*inode) && filp->f_version != PIPE_WCOUNTER(*inode)) 451 if (!inode->i_pipe->writers && filp->f_version != inode->i_pipe->w_counter)
452 mask |= POLLHUP; 452 mask |= POLLHUP;
453 } 453 }
454 454
@@ -458,7 +458,7 @@ pipe_poll(struct file *filp, poll_table *wait)
458 * Most Unices do not set POLLERR for FIFOs but on Linux they 458 * Most Unices do not set POLLERR for FIFOs but on Linux they
459 * behave exactly like pipes for poll(). 459 * behave exactly like pipes for poll().
460 */ 460 */
461 if (!PIPE_READERS(*inode)) 461 if (!inode->i_pipe->readers)
462 mask |= POLLERR; 462 mask |= POLLERR;
463 } 463 }
464 464
@@ -468,17 +468,17 @@ pipe_poll(struct file *filp, poll_table *wait)
468static int 468static int
469pipe_release(struct inode *inode, int decr, int decw) 469pipe_release(struct inode *inode, int decr, int decw)
470{ 470{
471 mutex_lock(PIPE_MUTEX(*inode)); 471 mutex_lock(&inode->i_mutex);
472 PIPE_READERS(*inode) -= decr; 472 inode->i_pipe->readers -= decr;
473 PIPE_WRITERS(*inode) -= decw; 473 inode->i_pipe->writers -= decw;
474 if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode)) { 474 if (!inode->i_pipe->readers && !inode->i_pipe->writers) {
475 free_pipe_info(inode); 475 free_pipe_info(inode);
476 } else { 476 } else {
477 wake_up_interruptible(PIPE_WAIT(*inode)); 477 wake_up_interruptible(&inode->i_pipe->wait);
478 kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN); 478 kill_fasync(&inode->i_pipe->fasync_readers, SIGIO, POLL_IN);
479 kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT); 479 kill_fasync(&inode->i_pipe->fasync_writers, SIGIO, POLL_OUT);
480 } 480 }
481 mutex_unlock(PIPE_MUTEX(*inode)); 481 mutex_unlock(&inode->i_mutex);
482 482
483 return 0; 483 return 0;
484} 484}
@@ -489,9 +489,9 @@ pipe_read_fasync(int fd, struct file *filp, int on)
489 struct inode *inode = filp->f_dentry->d_inode; 489 struct inode *inode = filp->f_dentry->d_inode;
490 int retval; 490 int retval;
491 491
492 mutex_lock(PIPE_MUTEX(*inode)); 492 mutex_lock(&inode->i_mutex);
493 retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode)); 493 retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_readers);
494 mutex_unlock(PIPE_MUTEX(*inode)); 494 mutex_unlock(&inode->i_mutex);
495 495
496 if (retval < 0) 496 if (retval < 0)
497 return retval; 497 return retval;
@@ -506,9 +506,9 @@ pipe_write_fasync(int fd, struct file *filp, int on)
506 struct inode *inode = filp->f_dentry->d_inode; 506 struct inode *inode = filp->f_dentry->d_inode;
507 int retval; 507 int retval;
508 508
509 mutex_lock(PIPE_MUTEX(*inode)); 509 mutex_lock(&inode->i_mutex);
510 retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode)); 510 retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_writers);
511 mutex_unlock(PIPE_MUTEX(*inode)); 511 mutex_unlock(&inode->i_mutex);
512 512
513 if (retval < 0) 513 if (retval < 0)
514 return retval; 514 return retval;
@@ -523,14 +523,14 @@ pipe_rdwr_fasync(int fd, struct file *filp, int on)
523 struct inode *inode = filp->f_dentry->d_inode; 523 struct inode *inode = filp->f_dentry->d_inode;
524 int retval; 524 int retval;
525 525
526 mutex_lock(PIPE_MUTEX(*inode)); 526 mutex_lock(&inode->i_mutex);
527 527
528 retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode)); 528 retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_readers);
529 529
530 if (retval >= 0) 530 if (retval >= 0)
531 retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode)); 531 retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_writers);
532 532
533 mutex_unlock(PIPE_MUTEX(*inode)); 533 mutex_unlock(&inode->i_mutex);
534 534
535 if (retval < 0) 535 if (retval < 0)
536 return retval; 536 return retval;
@@ -569,9 +569,9 @@ pipe_read_open(struct inode *inode, struct file *filp)
569{ 569{
570 /* We could have perhaps used atomic_t, but this and friends 570 /* We could have perhaps used atomic_t, but this and friends
571 below are the only places. So it doesn't seem worthwhile. */ 571 below are the only places. So it doesn't seem worthwhile. */
572 mutex_lock(PIPE_MUTEX(*inode)); 572 mutex_lock(&inode->i_mutex);
573 PIPE_READERS(*inode)++; 573 inode->i_pipe->readers++;
574 mutex_unlock(PIPE_MUTEX(*inode)); 574 mutex_unlock(&inode->i_mutex);
575 575
576 return 0; 576 return 0;
577} 577}
@@ -579,9 +579,9 @@ pipe_read_open(struct inode *inode, struct file *filp)
579static int 579static int
580pipe_write_open(struct inode *inode, struct file *filp) 580pipe_write_open(struct inode *inode, struct file *filp)
581{ 581{
582 mutex_lock(PIPE_MUTEX(*inode)); 582 mutex_lock(&inode->i_mutex);
583 PIPE_WRITERS(*inode)++; 583 inode->i_pipe->writers++;
584 mutex_unlock(PIPE_MUTEX(*inode)); 584 mutex_unlock(&inode->i_mutex);
585 585
586 return 0; 586 return 0;
587} 587}
@@ -589,12 +589,12 @@ pipe_write_open(struct inode *inode, struct file *filp)
589static int 589static int
590pipe_rdwr_open(struct inode *inode, struct file *filp) 590pipe_rdwr_open(struct inode *inode, struct file *filp)
591{ 591{
592 mutex_lock(PIPE_MUTEX(*inode)); 592 mutex_lock(&inode->i_mutex);
593 if (filp->f_mode & FMODE_READ) 593 if (filp->f_mode & FMODE_READ)
594 PIPE_READERS(*inode)++; 594 inode->i_pipe->readers++;
595 if (filp->f_mode & FMODE_WRITE) 595 if (filp->f_mode & FMODE_WRITE)
596 PIPE_WRITERS(*inode)++; 596 inode->i_pipe->writers++;
597 mutex_unlock(PIPE_MUTEX(*inode)); 597 mutex_unlock(&inode->i_mutex);
598 598
599 return 0; 599 return 0;
600} 600}
@@ -731,7 +731,7 @@ static struct inode * get_pipe_inode(void)
731 if (!inode->i_pipe) 731 if (!inode->i_pipe)
732 goto fail_iput; 732 goto fail_iput;
733 733
734 PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1; 734 inode->i_pipe->readers = inode->i_pipe->writers = 1;
735 inode->i_fop = &rdwr_pipe_fops; 735 inode->i_fop = &rdwr_pipe_fops;
736 736
737 /* 737 /*
diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
index 660e9d866e5d..123a7c24bc72 100644
--- a/include/linux/pipe_fs_i.h
+++ b/include/linux/pipe_fs_i.h
@@ -43,16 +43,6 @@ struct pipe_inode_info {
43 memory allocation, whereas PIPE_BUF makes atomicity guarantees. */ 43 memory allocation, whereas PIPE_BUF makes atomicity guarantees. */
44#define PIPE_SIZE PAGE_SIZE 44#define PIPE_SIZE PAGE_SIZE
45 45
46#define PIPE_MUTEX(inode) (&(inode).i_mutex)
47#define PIPE_WAIT(inode) (&(inode).i_pipe->wait)
48#define PIPE_READERS(inode) ((inode).i_pipe->readers)
49#define PIPE_WRITERS(inode) ((inode).i_pipe->writers)
50#define PIPE_WAITING_WRITERS(inode) ((inode).i_pipe->waiting_writers)
51#define PIPE_RCOUNTER(inode) ((inode).i_pipe->r_counter)
52#define PIPE_WCOUNTER(inode) ((inode).i_pipe->w_counter)
53#define PIPE_FASYNC_READERS(inode) (&((inode).i_pipe->fasync_readers))
54#define PIPE_FASYNC_WRITERS(inode) (&((inode).i_pipe->fasync_writers))
55
56/* Drop the inode semaphore and wait for a pipe event, atomically */ 46/* Drop the inode semaphore and wait for a pipe event, atomically */
57void pipe_wait(struct pipe_inode_info *pipe); 47void pipe_wait(struct pipe_inode_info *pipe);
58 48
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-12 02:22:09 -0500