diff options
author | David S. Miller <davem@davemloft.net> | 2008-12-02 22:50:27 -0500 |
---|---|---|
committer | David S. Miller <davem@davemloft.net> | 2008-12-02 22:50:27 -0500 |
commit | aa2ba5f1082dc705745899584aac8416d710c056 (patch) | |
tree | bde0bf4aff036c6bac19a0212194ae1092afb3c9 /fs | |
parent | 68024541e2e5a8f35e281daaa5068a29e2a538a5 (diff) | |
parent | f6f7b52e2f6149d2ee365717afff315b05720162 (diff) |
Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
Conflicts:
drivers/net/ixgbe/ixgbe_main.c
drivers/net/smc91x.c
Diffstat (limited to 'fs')
-rw-r--r-- | fs/buffer.c | 1 | ||||
-rw-r--r-- | fs/cifs/file.c | 77 | ||||
-rw-r--r-- | fs/eventpoll.c | 85 | ||||
-rw-r--r-- | fs/ntfs/debug.h | 8 | ||||
-rw-r--r-- | fs/ocfs2/buffer_head_io.c | 15 | ||||
-rw-r--r-- | fs/ocfs2/dlm/dlmfs.c | 4 | ||||
-rw-r--r-- | fs/ocfs2/dlm/userdlm.h | 2 | ||||
-rw-r--r-- | fs/ocfs2/dlmglue.c | 3 | ||||
-rw-r--r-- | fs/ocfs2/ocfs2.h | 2 | ||||
-rw-r--r-- | fs/ocfs2/stack_user.c | 3 | ||||
-rw-r--r-- | fs/ubifs/commit.c | 4 | ||||
-rw-r--r-- | fs/ubifs/debug.c | 66 | ||||
-rw-r--r-- | fs/ubifs/dir.c | 5 | ||||
-rw-r--r-- | fs/ubifs/file.c | 91 | ||||
-rw-r--r-- | fs/ubifs/journal.c | 8 | ||||
-rw-r--r-- | fs/ubifs/key.h | 4 | ||||
-rw-r--r-- | fs/ubifs/lpt_commit.c | 2 | ||||
-rw-r--r-- | fs/ubifs/orphan.c | 28 | ||||
-rw-r--r-- | fs/ubifs/recovery.c | 17 | ||||
-rw-r--r-- | fs/ubifs/replay.c | 2 | ||||
-rw-r--r-- | fs/ubifs/sb.c | 9 | ||||
-rw-r--r-- | fs/ubifs/super.c | 70 | ||||
-rw-r--r-- | fs/ubifs/tnc.c | 12 | ||||
-rw-r--r-- | fs/ubifs/ubifs.h | 12 | ||||
-rw-r--r-- | fs/udf/inode.c | 1 |
25 files changed, 371 insertions, 160 deletions
diff --git a/fs/buffer.c b/fs/buffer.c index 6569fda5cfe..10179cfa115 100644 --- a/fs/buffer.c +++ b/fs/buffer.c | |||
@@ -878,6 +878,7 @@ void invalidate_inode_buffers(struct inode *inode) | |||
878 | spin_unlock(&buffer_mapping->private_lock); | 878 | spin_unlock(&buffer_mapping->private_lock); |
879 | } | 879 | } |
880 | } | 880 | } |
881 | EXPORT_SYMBOL(invalidate_inode_buffers); | ||
881 | 882 | ||
882 | /* | 883 | /* |
883 | * Remove any clean buffers from the inode's buffer list. This is called | 884 | * Remove any clean buffers from the inode's buffer list. This is called |
diff --git a/fs/cifs/file.c b/fs/cifs/file.c index b691b893a84..f0a81e631ae 100644 --- a/fs/cifs/file.c +++ b/fs/cifs/file.c | |||
@@ -1475,7 +1475,11 @@ static int cifs_write_end(struct file *file, struct address_space *mapping, | |||
1475 | cFYI(1, ("write_end for page %p from pos %lld with %d bytes", | 1475 | cFYI(1, ("write_end for page %p from pos %lld with %d bytes", |
1476 | page, pos, copied)); | 1476 | page, pos, copied)); |
1477 | 1477 | ||
1478 | if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE) | 1478 | if (PageChecked(page)) { |
1479 | if (copied == len) | ||
1480 | SetPageUptodate(page); | ||
1481 | ClearPageChecked(page); | ||
1482 | } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE) | ||
1479 | SetPageUptodate(page); | 1483 | SetPageUptodate(page); |
1480 | 1484 | ||
1481 | if (!PageUptodate(page)) { | 1485 | if (!PageUptodate(page)) { |
@@ -2062,39 +2066,70 @@ static int cifs_write_begin(struct file *file, struct address_space *mapping, | |||
2062 | { | 2066 | { |
2063 | pgoff_t index = pos >> PAGE_CACHE_SHIFT; | 2067 | pgoff_t index = pos >> PAGE_CACHE_SHIFT; |
2064 | loff_t offset = pos & (PAGE_CACHE_SIZE - 1); | 2068 | loff_t offset = pos & (PAGE_CACHE_SIZE - 1); |
2069 | loff_t page_start = pos & PAGE_MASK; | ||
2070 | loff_t i_size; | ||
2071 | struct page *page; | ||
2072 | int rc = 0; | ||
2065 | 2073 | ||
2066 | cFYI(1, ("write_begin from %lld len %d", (long long)pos, len)); | 2074 | cFYI(1, ("write_begin from %lld len %d", (long long)pos, len)); |
2067 | 2075 | ||
2068 | *pagep = __grab_cache_page(mapping, index); | 2076 | page = __grab_cache_page(mapping, index); |
2069 | if (!*pagep) | 2077 | if (!page) { |
2070 | return -ENOMEM; | 2078 | rc = -ENOMEM; |
2071 | 2079 | goto out; | |
2072 | if (PageUptodate(*pagep)) | 2080 | } |
2073 | return 0; | ||
2074 | 2081 | ||
2075 | /* If we are writing a full page it will be up to date, | 2082 | if (PageUptodate(page)) |
2076 | no need to read from the server */ | 2083 | goto out; |
2077 | if (len == PAGE_CACHE_SIZE && flags & AOP_FLAG_UNINTERRUPTIBLE) | ||
2078 | return 0; | ||
2079 | 2084 | ||
2080 | if ((file->f_flags & O_ACCMODE) != O_WRONLY) { | 2085 | /* |
2081 | int rc; | 2086 | * If we write a full page it will be up to date, no need to read from |
2087 | * the server. If the write is short, we'll end up doing a sync write | ||
2088 | * instead. | ||
2089 | */ | ||
2090 | if (len == PAGE_CACHE_SIZE) | ||
2091 | goto out; | ||
2082 | 2092 | ||
2083 | /* might as well read a page, it is fast enough */ | 2093 | /* |
2084 | rc = cifs_readpage_worker(file, *pagep, &offset); | 2094 | * optimize away the read when we have an oplock, and we're not |
2095 | * expecting to use any of the data we'd be reading in. That | ||
2096 | * is, when the page lies beyond the EOF, or straddles the EOF | ||
2097 | * and the write will cover all of the existing data. | ||
2098 | */ | ||
2099 | if (CIFS_I(mapping->host)->clientCanCacheRead) { | ||
2100 | i_size = i_size_read(mapping->host); | ||
2101 | if (page_start >= i_size || | ||
2102 | (offset == 0 && (pos + len) >= i_size)) { | ||
2103 | zero_user_segments(page, 0, offset, | ||
2104 | offset + len, | ||
2105 | PAGE_CACHE_SIZE); | ||
2106 | /* | ||
2107 | * PageChecked means that the parts of the page | ||
2108 | * to which we're not writing are considered up | ||
2109 | * to date. Once the data is copied to the | ||
2110 | * page, it can be set uptodate. | ||
2111 | */ | ||
2112 | SetPageChecked(page); | ||
2113 | goto out; | ||
2114 | } | ||
2115 | } | ||
2085 | 2116 | ||
2086 | /* we do not need to pass errors back | 2117 | if ((file->f_flags & O_ACCMODE) != O_WRONLY) { |
2087 | e.g. if we do not have read access to the file | 2118 | /* |
2088 | because cifs_write_end will attempt synchronous writes | 2119 | * might as well read a page, it is fast enough. If we get |
2089 | -- shaggy */ | 2120 | * an error, we don't need to return it. cifs_write_end will |
2121 | * do a sync write instead since PG_uptodate isn't set. | ||
2122 | */ | ||
2123 | cifs_readpage_worker(file, page, &page_start); | ||
2090 | } else { | 2124 | } else { |
2091 | /* we could try using another file handle if there is one - | 2125 | /* we could try using another file handle if there is one - |
2092 | but how would we lock it to prevent close of that handle | 2126 | but how would we lock it to prevent close of that handle |
2093 | racing with this read? In any case | 2127 | racing with this read? In any case |
2094 | this will be written out by write_end so is fine */ | 2128 | this will be written out by write_end so is fine */ |
2095 | } | 2129 | } |
2096 | 2130 | out: | |
2097 | return 0; | 2131 | *pagep = page; |
2132 | return rc; | ||
2098 | } | 2133 | } |
2099 | 2134 | ||
2100 | const struct address_space_operations cifs_addr_ops = { | 2135 | const struct address_space_operations cifs_addr_ops = { |
diff --git a/fs/eventpoll.c b/fs/eventpoll.c index aec5c13f634..96355d50534 100644 --- a/fs/eventpoll.c +++ b/fs/eventpoll.c | |||
@@ -102,6 +102,8 @@ | |||
102 | 102 | ||
103 | #define EP_UNACTIVE_PTR ((void *) -1L) | 103 | #define EP_UNACTIVE_PTR ((void *) -1L) |
104 | 104 | ||
105 | #define EP_ITEM_COST (sizeof(struct epitem) + sizeof(struct eppoll_entry)) | ||
106 | |||
105 | struct epoll_filefd { | 107 | struct epoll_filefd { |
106 | struct file *file; | 108 | struct file *file; |
107 | int fd; | 109 | int fd; |
@@ -200,6 +202,9 @@ struct eventpoll { | |||
200 | * holding ->lock. | 202 | * holding ->lock. |
201 | */ | 203 | */ |
202 | struct epitem *ovflist; | 204 | struct epitem *ovflist; |
205 | |||
206 | /* The user that created the eventpoll descriptor */ | ||
207 | struct user_struct *user; | ||
203 | }; | 208 | }; |
204 | 209 | ||
205 | /* Wait structure used by the poll hooks */ | 210 | /* Wait structure used by the poll hooks */ |
@@ -227,9 +232,17 @@ struct ep_pqueue { | |||
227 | }; | 232 | }; |
228 | 233 | ||
229 | /* | 234 | /* |
235 | * Configuration options available inside /proc/sys/fs/epoll/ | ||
236 | */ | ||
237 | /* Maximum number of epoll devices, per user */ | ||
238 | static int max_user_instances __read_mostly; | ||
239 | /* Maximum number of epoll watched descriptors, per user */ | ||
240 | static int max_user_watches __read_mostly; | ||
241 | |||
242 | /* | ||
230 | * This mutex is used to serialize ep_free() and eventpoll_release_file(). | 243 | * This mutex is used to serialize ep_free() and eventpoll_release_file(). |
231 | */ | 244 | */ |
232 | static struct mutex epmutex; | 245 | static DEFINE_MUTEX(epmutex); |
233 | 246 | ||
234 | /* Safe wake up implementation */ | 247 | /* Safe wake up implementation */ |
235 | static struct poll_safewake psw; | 248 | static struct poll_safewake psw; |
@@ -240,6 +253,33 @@ static struct kmem_cache *epi_cache __read_mostly; | |||
240 | /* Slab cache used to allocate "struct eppoll_entry" */ | 253 | /* Slab cache used to allocate "struct eppoll_entry" */ |
241 | static struct kmem_cache *pwq_cache __read_mostly; | 254 | static struct kmem_cache *pwq_cache __read_mostly; |
242 | 255 | ||
256 | #ifdef CONFIG_SYSCTL | ||
257 | |||
258 | #include <linux/sysctl.h> | ||
259 | |||
260 | static int zero; | ||
261 | |||
262 | ctl_table epoll_table[] = { | ||
263 | { | ||
264 | .procname = "max_user_instances", | ||
265 | .data = &max_user_instances, | ||
266 | .maxlen = sizeof(int), | ||
267 | .mode = 0644, | ||
268 | .proc_handler = &proc_dointvec_minmax, | ||
269 | .extra1 = &zero, | ||
270 | }, | ||
271 | { | ||
272 | .procname = "max_user_watches", | ||
273 | .data = &max_user_watches, | ||
274 | .maxlen = sizeof(int), | ||
275 | .mode = 0644, | ||
276 | .proc_handler = &proc_dointvec_minmax, | ||
277 | .extra1 = &zero, | ||
278 | }, | ||
279 | { .ctl_name = 0 } | ||
280 | }; | ||
281 | #endif /* CONFIG_SYSCTL */ | ||
282 | |||
243 | 283 | ||
244 | /* Setup the structure that is used as key for the RB tree */ | 284 | /* Setup the structure that is used as key for the RB tree */ |
245 | static inline void ep_set_ffd(struct epoll_filefd *ffd, | 285 | static inline void ep_set_ffd(struct epoll_filefd *ffd, |
@@ -402,6 +442,8 @@ static int ep_remove(struct eventpoll *ep, struct epitem *epi) | |||
402 | /* At this point it is safe to free the eventpoll item */ | 442 | /* At this point it is safe to free the eventpoll item */ |
403 | kmem_cache_free(epi_cache, epi); | 443 | kmem_cache_free(epi_cache, epi); |
404 | 444 | ||
445 | atomic_dec(&ep->user->epoll_watches); | ||
446 | |||
405 | DNPRINTK(3, (KERN_INFO "[%p] eventpoll: ep_remove(%p, %p)\n", | 447 | DNPRINTK(3, (KERN_INFO "[%p] eventpoll: ep_remove(%p, %p)\n", |
406 | current, ep, file)); | 448 | current, ep, file)); |
407 | 449 | ||
@@ -449,6 +491,8 @@ static void ep_free(struct eventpoll *ep) | |||
449 | 491 | ||
450 | mutex_unlock(&epmutex); | 492 | mutex_unlock(&epmutex); |
451 | mutex_destroy(&ep->mtx); | 493 | mutex_destroy(&ep->mtx); |
494 | atomic_dec(&ep->user->epoll_devs); | ||
495 | free_uid(ep->user); | ||
452 | kfree(ep); | 496 | kfree(ep); |
453 | } | 497 | } |
454 | 498 | ||
@@ -532,10 +576,19 @@ void eventpoll_release_file(struct file *file) | |||
532 | 576 | ||
533 | static int ep_alloc(struct eventpoll **pep) | 577 | static int ep_alloc(struct eventpoll **pep) |
534 | { | 578 | { |
535 | struct eventpoll *ep = kzalloc(sizeof(*ep), GFP_KERNEL); | 579 | int error; |
580 | struct user_struct *user; | ||
581 | struct eventpoll *ep; | ||
536 | 582 | ||
537 | if (!ep) | 583 | user = get_current_user(); |
538 | return -ENOMEM; | 584 | error = -EMFILE; |
585 | if (unlikely(atomic_read(&user->epoll_devs) >= | ||
586 | max_user_instances)) | ||
587 | goto free_uid; | ||
588 | error = -ENOMEM; | ||
589 | ep = kzalloc(sizeof(*ep), GFP_KERNEL); | ||
590 | if (unlikely(!ep)) | ||
591 | goto free_uid; | ||
539 | 592 | ||
540 | spin_lock_init(&ep->lock); | 593 | spin_lock_init(&ep->lock); |
541 | mutex_init(&ep->mtx); | 594 | mutex_init(&ep->mtx); |
@@ -544,12 +597,17 @@ static int ep_alloc(struct eventpoll **pep) | |||
544 | INIT_LIST_HEAD(&ep->rdllist); | 597 | INIT_LIST_HEAD(&ep->rdllist); |
545 | ep->rbr = RB_ROOT; | 598 | ep->rbr = RB_ROOT; |
546 | ep->ovflist = EP_UNACTIVE_PTR; | 599 | ep->ovflist = EP_UNACTIVE_PTR; |
600 | ep->user = user; | ||
547 | 601 | ||
548 | *pep = ep; | 602 | *pep = ep; |
549 | 603 | ||
550 | DNPRINTK(3, (KERN_INFO "[%p] eventpoll: ep_alloc() ep=%p\n", | 604 | DNPRINTK(3, (KERN_INFO "[%p] eventpoll: ep_alloc() ep=%p\n", |
551 | current, ep)); | 605 | current, ep)); |
552 | return 0; | 606 | return 0; |
607 | |||
608 | free_uid: | ||
609 | free_uid(user); | ||
610 | return error; | ||
553 | } | 611 | } |
554 | 612 | ||
555 | /* | 613 | /* |
@@ -703,9 +761,11 @@ static int ep_insert(struct eventpoll *ep, struct epoll_event *event, | |||
703 | struct epitem *epi; | 761 | struct epitem *epi; |
704 | struct ep_pqueue epq; | 762 | struct ep_pqueue epq; |
705 | 763 | ||
706 | error = -ENOMEM; | 764 | if (unlikely(atomic_read(&ep->user->epoll_watches) >= |
765 | max_user_watches)) | ||
766 | return -ENOSPC; | ||
707 | if (!(epi = kmem_cache_alloc(epi_cache, GFP_KERNEL))) | 767 | if (!(epi = kmem_cache_alloc(epi_cache, GFP_KERNEL))) |
708 | goto error_return; | 768 | return -ENOMEM; |
709 | 769 | ||
710 | /* Item initialization follow here ... */ | 770 | /* Item initialization follow here ... */ |
711 | INIT_LIST_HEAD(&epi->rdllink); | 771 | INIT_LIST_HEAD(&epi->rdllink); |
@@ -735,6 +795,7 @@ static int ep_insert(struct eventpoll *ep, struct epoll_event *event, | |||
735 | * install process. Namely an allocation for a wait queue failed due | 795 | * install process. Namely an allocation for a wait queue failed due |
736 | * high memory pressure. | 796 | * high memory pressure. |
737 | */ | 797 | */ |
798 | error = -ENOMEM; | ||
738 | if (epi->nwait < 0) | 799 | if (epi->nwait < 0) |
739 | goto error_unregister; | 800 | goto error_unregister; |
740 | 801 | ||
@@ -765,6 +826,8 @@ static int ep_insert(struct eventpoll *ep, struct epoll_event *event, | |||
765 | 826 | ||
766 | spin_unlock_irqrestore(&ep->lock, flags); | 827 | spin_unlock_irqrestore(&ep->lock, flags); |
767 | 828 | ||
829 | atomic_inc(&ep->user->epoll_watches); | ||
830 | |||
768 | /* We have to call this outside the lock */ | 831 | /* We have to call this outside the lock */ |
769 | if (pwake) | 832 | if (pwake) |
770 | ep_poll_safewake(&psw, &ep->poll_wait); | 833 | ep_poll_safewake(&psw, &ep->poll_wait); |
@@ -789,7 +852,7 @@ error_unregister: | |||
789 | spin_unlock_irqrestore(&ep->lock, flags); | 852 | spin_unlock_irqrestore(&ep->lock, flags); |
790 | 853 | ||
791 | kmem_cache_free(epi_cache, epi); | 854 | kmem_cache_free(epi_cache, epi); |
792 | error_return: | 855 | |
793 | return error; | 856 | return error; |
794 | } | 857 | } |
795 | 858 | ||
@@ -1078,6 +1141,7 @@ asmlinkage long sys_epoll_create1(int flags) | |||
1078 | flags & O_CLOEXEC); | 1141 | flags & O_CLOEXEC); |
1079 | if (fd < 0) | 1142 | if (fd < 0) |
1080 | ep_free(ep); | 1143 | ep_free(ep); |
1144 | atomic_inc(&ep->user->epoll_devs); | ||
1081 | 1145 | ||
1082 | error_return: | 1146 | error_return: |
1083 | DNPRINTK(3, (KERN_INFO "[%p] eventpoll: sys_epoll_create(%d) = %d\n", | 1147 | DNPRINTK(3, (KERN_INFO "[%p] eventpoll: sys_epoll_create(%d) = %d\n", |
@@ -1299,7 +1363,12 @@ asmlinkage long sys_epoll_pwait(int epfd, struct epoll_event __user *events, | |||
1299 | 1363 | ||
1300 | static int __init eventpoll_init(void) | 1364 | static int __init eventpoll_init(void) |
1301 | { | 1365 | { |
1302 | mutex_init(&epmutex); | 1366 | struct sysinfo si; |
1367 | |||
1368 | si_meminfo(&si); | ||
1369 | max_user_instances = 128; | ||
1370 | max_user_watches = (((si.totalram - si.totalhigh) / 32) << PAGE_SHIFT) / | ||
1371 | EP_ITEM_COST; | ||
1303 | 1372 | ||
1304 | /* Initialize the structure used to perform safe poll wait head wake ups */ | 1373 | /* Initialize the structure used to perform safe poll wait head wake ups */ |
1305 | ep_poll_safewake_init(&psw); | 1374 | ep_poll_safewake_init(&psw); |
diff --git a/fs/ntfs/debug.h b/fs/ntfs/debug.h index 5e6724c1afd..2142b1c68b6 100644 --- a/fs/ntfs/debug.h +++ b/fs/ntfs/debug.h | |||
@@ -30,7 +30,8 @@ | |||
30 | 30 | ||
31 | extern int debug_msgs; | 31 | extern int debug_msgs; |
32 | 32 | ||
33 | #if 0 /* Fool kernel-doc since it doesn't do macros yet */ | 33 | extern void __ntfs_debug(const char *file, int line, const char *function, |
34 | const char *format, ...) __attribute__ ((format (printf, 4, 5))); | ||
34 | /** | 35 | /** |
35 | * ntfs_debug - write a debug level message to syslog | 36 | * ntfs_debug - write a debug level message to syslog |
36 | * @f: a printf format string containing the message | 37 | * @f: a printf format string containing the message |
@@ -39,11 +40,6 @@ extern int debug_msgs; | |||
39 | * ntfs_debug() writes a DEBUG level message to the syslog but only if the | 40 | * ntfs_debug() writes a DEBUG level message to the syslog but only if the |
40 | * driver was compiled with -DDEBUG. Otherwise, the call turns into a NOP. | 41 | * driver was compiled with -DDEBUG. Otherwise, the call turns into a NOP. |
41 | */ | 42 | */ |
42 | static void ntfs_debug(const char *f, ...); | ||
43 | #endif | ||
44 | |||
45 | extern void __ntfs_debug (const char *file, int line, const char *function, | ||
46 | const char *format, ...) __attribute__ ((format (printf, 4, 5))); | ||
47 | #define ntfs_debug(f, a...) \ | 43 | #define ntfs_debug(f, a...) \ |
48 | __ntfs_debug(__FILE__, __LINE__, __func__, f, ##a) | 44 | __ntfs_debug(__FILE__, __LINE__, __func__, f, ##a) |
49 | 45 | ||
diff --git a/fs/ocfs2/buffer_head_io.c b/fs/ocfs2/buffer_head_io.c index 7e947c67246..3a178ec48d7 100644 --- a/fs/ocfs2/buffer_head_io.c +++ b/fs/ocfs2/buffer_head_io.c | |||
@@ -112,7 +112,7 @@ int ocfs2_read_blocks_sync(struct ocfs2_super *osb, u64 block, | |||
112 | bh = bhs[i]; | 112 | bh = bhs[i]; |
113 | 113 | ||
114 | if (buffer_jbd(bh)) { | 114 | if (buffer_jbd(bh)) { |
115 | mlog(ML_ERROR, | 115 | mlog(ML_BH_IO, |
116 | "trying to sync read a jbd " | 116 | "trying to sync read a jbd " |
117 | "managed bh (blocknr = %llu), skipping\n", | 117 | "managed bh (blocknr = %llu), skipping\n", |
118 | (unsigned long long)bh->b_blocknr); | 118 | (unsigned long long)bh->b_blocknr); |
@@ -147,15 +147,10 @@ int ocfs2_read_blocks_sync(struct ocfs2_super *osb, u64 block, | |||
147 | for (i = nr; i > 0; i--) { | 147 | for (i = nr; i > 0; i--) { |
148 | bh = bhs[i - 1]; | 148 | bh = bhs[i - 1]; |
149 | 149 | ||
150 | if (buffer_jbd(bh)) { | 150 | /* No need to wait on the buffer if it's managed by JBD. */ |
151 | mlog(ML_ERROR, | 151 | if (!buffer_jbd(bh)) |
152 | "the journal got the buffer while it was " | 152 | wait_on_buffer(bh); |
153 | "locked for io! (blocknr = %llu)\n", | ||
154 | (unsigned long long)bh->b_blocknr); | ||
155 | BUG(); | ||
156 | } | ||
157 | 153 | ||
158 | wait_on_buffer(bh); | ||
159 | if (!buffer_uptodate(bh)) { | 154 | if (!buffer_uptodate(bh)) { |
160 | /* Status won't be cleared from here on out, | 155 | /* Status won't be cleared from here on out, |
161 | * so we can safely record this and loop back | 156 | * so we can safely record this and loop back |
@@ -251,8 +246,6 @@ int ocfs2_read_blocks(struct inode *inode, u64 block, int nr, | |||
251 | ignore_cache = 1; | 246 | ignore_cache = 1; |
252 | } | 247 | } |
253 | 248 | ||
254 | /* XXX: Can we ever get this and *not* have the cached | ||
255 | * flag set? */ | ||
256 | if (buffer_jbd(bh)) { | 249 | if (buffer_jbd(bh)) { |
257 | if (ignore_cache) | 250 | if (ignore_cache) |
258 | mlog(ML_BH_IO, "trying to sync read a jbd " | 251 | mlog(ML_BH_IO, "trying to sync read a jbd " |
diff --git a/fs/ocfs2/dlm/dlmfs.c b/fs/ocfs2/dlm/dlmfs.c index 533a789c3ef..ba962d71b34 100644 --- a/fs/ocfs2/dlm/dlmfs.c +++ b/fs/ocfs2/dlm/dlmfs.c | |||
@@ -608,8 +608,10 @@ static int __init init_dlmfs_fs(void) | |||
608 | 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| | 608 | 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| |
609 | SLAB_MEM_SPREAD), | 609 | SLAB_MEM_SPREAD), |
610 | dlmfs_init_once); | 610 | dlmfs_init_once); |
611 | if (!dlmfs_inode_cache) | 611 | if (!dlmfs_inode_cache) { |
612 | status = -ENOMEM; | ||
612 | goto bail; | 613 | goto bail; |
614 | } | ||
613 | cleanup_inode = 1; | 615 | cleanup_inode = 1; |
614 | 616 | ||
615 | user_dlm_worker = create_singlethread_workqueue("user_dlm"); | 617 | user_dlm_worker = create_singlethread_workqueue("user_dlm"); |
diff --git a/fs/ocfs2/dlm/userdlm.h b/fs/ocfs2/dlm/userdlm.h index 39ec2773849..0c3cc03c61f 100644 --- a/fs/ocfs2/dlm/userdlm.h +++ b/fs/ocfs2/dlm/userdlm.h | |||
@@ -33,7 +33,7 @@ | |||
33 | #include <linux/workqueue.h> | 33 | #include <linux/workqueue.h> |
34 | 34 | ||
35 | /* user_lock_res->l_flags flags. */ | 35 | /* user_lock_res->l_flags flags. */ |
36 | #define USER_LOCK_ATTACHED (0x00000001) /* have we initialized | 36 | #define USER_LOCK_ATTACHED (0x00000001) /* we have initialized |
37 | * the lvb */ | 37 | * the lvb */ |
38 | #define USER_LOCK_BUSY (0x00000002) /* we are currently in | 38 | #define USER_LOCK_BUSY (0x00000002) /* we are currently in |
39 | * dlm_lock */ | 39 | * dlm_lock */ |
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c index ec684426034..6e6cc0a2e5f 100644 --- a/fs/ocfs2/dlmglue.c +++ b/fs/ocfs2/dlmglue.c | |||
@@ -2841,9 +2841,8 @@ static void ocfs2_unlock_ast(void *opaque, int error) | |||
2841 | 2841 | ||
2842 | lockres_clear_flags(lockres, OCFS2_LOCK_BUSY); | 2842 | lockres_clear_flags(lockres, OCFS2_LOCK_BUSY); |
2843 | lockres->l_unlock_action = OCFS2_UNLOCK_INVALID; | 2843 | lockres->l_unlock_action = OCFS2_UNLOCK_INVALID; |
2844 | spin_unlock_irqrestore(&lockres->l_lock, flags); | ||
2845 | |||
2846 | wake_up(&lockres->l_event); | 2844 | wake_up(&lockres->l_event); |
2845 | spin_unlock_irqrestore(&lockres->l_lock, flags); | ||
2847 | 2846 | ||
2848 | mlog_exit_void(); | 2847 | mlog_exit_void(); |
2849 | } | 2848 | } |
diff --git a/fs/ocfs2/ocfs2.h b/fs/ocfs2/ocfs2.h index fef7ece3237..3fed9e3d899 100644 --- a/fs/ocfs2/ocfs2.h +++ b/fs/ocfs2/ocfs2.h | |||
@@ -85,7 +85,7 @@ enum ocfs2_unlock_action { | |||
85 | }; | 85 | }; |
86 | 86 | ||
87 | /* ocfs2_lock_res->l_flags flags. */ | 87 | /* ocfs2_lock_res->l_flags flags. */ |
88 | #define OCFS2_LOCK_ATTACHED (0x00000001) /* have we initialized | 88 | #define OCFS2_LOCK_ATTACHED (0x00000001) /* we have initialized |
89 | * the lvb */ | 89 | * the lvb */ |
90 | #define OCFS2_LOCK_BUSY (0x00000002) /* we are currently in | 90 | #define OCFS2_LOCK_BUSY (0x00000002) /* we are currently in |
91 | * dlm_lock */ | 91 | * dlm_lock */ |
diff --git a/fs/ocfs2/stack_user.c b/fs/ocfs2/stack_user.c index faec2d87935..9b76d41a8ac 100644 --- a/fs/ocfs2/stack_user.c +++ b/fs/ocfs2/stack_user.c | |||
@@ -740,6 +740,9 @@ static int user_dlm_lock_status(union ocfs2_dlm_lksb *lksb) | |||
740 | 740 | ||
741 | static void *user_dlm_lvb(union ocfs2_dlm_lksb *lksb) | 741 | static void *user_dlm_lvb(union ocfs2_dlm_lksb *lksb) |
742 | { | 742 | { |
743 | if (!lksb->lksb_fsdlm.sb_lvbptr) | ||
744 | lksb->lksb_fsdlm.sb_lvbptr = (char *)lksb + | ||
745 | sizeof(struct dlm_lksb); | ||
743 | return (void *)(lksb->lksb_fsdlm.sb_lvbptr); | 746 | return (void *)(lksb->lksb_fsdlm.sb_lvbptr); |
744 | } | 747 | } |
745 | 748 | ||
diff --git a/fs/ubifs/commit.c b/fs/ubifs/commit.c index 0a6aa2cc78f..b49884c8c10 100644 --- a/fs/ubifs/commit.c +++ b/fs/ubifs/commit.c | |||
@@ -234,8 +234,8 @@ int ubifs_bg_thread(void *info) | |||
234 | int err; | 234 | int err; |
235 | struct ubifs_info *c = info; | 235 | struct ubifs_info *c = info; |
236 | 236 | ||
237 | ubifs_msg("background thread \"%s\" started, PID %d", | 237 | dbg_msg("background thread \"%s\" started, PID %d", |
238 | c->bgt_name, current->pid); | 238 | c->bgt_name, current->pid); |
239 | set_freezable(); | 239 | set_freezable(); |
240 | 240 | ||
241 | while (1) { | 241 | while (1) { |
diff --git a/fs/ubifs/debug.c b/fs/ubifs/debug.c index 7186400750e..510ffa0bbda 100644 --- a/fs/ubifs/debug.c +++ b/fs/ubifs/debug.c | |||
@@ -101,21 +101,24 @@ static void sprintf_key(const struct ubifs_info *c, const union ubifs_key *key, | |||
101 | if (c->key_fmt == UBIFS_SIMPLE_KEY_FMT) { | 101 | if (c->key_fmt == UBIFS_SIMPLE_KEY_FMT) { |
102 | switch (type) { | 102 | switch (type) { |
103 | case UBIFS_INO_KEY: | 103 | case UBIFS_INO_KEY: |
104 | sprintf(p, "(%lu, %s)", key_inum(c, key), | 104 | sprintf(p, "(%lu, %s)", (unsigned long)key_inum(c, key), |
105 | get_key_type(type)); | 105 | get_key_type(type)); |
106 | break; | 106 | break; |
107 | case UBIFS_DENT_KEY: | 107 | case UBIFS_DENT_KEY: |
108 | case UBIFS_XENT_KEY: | 108 | case UBIFS_XENT_KEY: |
109 | sprintf(p, "(%lu, %s, %#08x)", key_inum(c, key), | 109 | sprintf(p, "(%lu, %s, %#08x)", |
110 | (unsigned long)key_inum(c, key), | ||
110 | get_key_type(type), key_hash(c, key)); | 111 | get_key_type(type), key_hash(c, key)); |
111 | break; | 112 | break; |
112 | case UBIFS_DATA_KEY: | 113 | case UBIFS_DATA_KEY: |
113 | sprintf(p, "(%lu, %s, %u)", key_inum(c, key), | 114 | sprintf(p, "(%lu, %s, %u)", |
115 | (unsigned long)key_inum(c, key), | ||
114 | get_key_type(type), key_block(c, key)); | 116 | get_key_type(type), key_block(c, key)); |
115 | break; | 117 | break; |
116 | case UBIFS_TRUN_KEY: | 118 | case UBIFS_TRUN_KEY: |
117 | sprintf(p, "(%lu, %s)", | 119 | sprintf(p, "(%lu, %s)", |
118 | key_inum(c, key), get_key_type(type)); | 120 | (unsigned long)key_inum(c, key), |
121 | get_key_type(type)); | ||
119 | break; | 122 | break; |
120 | default: | 123 | default: |
121 | sprintf(p, "(bad key type: %#08x, %#08x)", | 124 | sprintf(p, "(bad key type: %#08x, %#08x)", |
@@ -364,8 +367,8 @@ void dbg_dump_node(const struct ubifs_info *c, const void *node) | |||
364 | le32_to_cpu(mst->ihead_lnum)); | 367 | le32_to_cpu(mst->ihead_lnum)); |
365 | printk(KERN_DEBUG "\tihead_offs %u\n", | 368 | printk(KERN_DEBUG "\tihead_offs %u\n", |
366 | le32_to_cpu(mst->ihead_offs)); | 369 | le32_to_cpu(mst->ihead_offs)); |
367 | printk(KERN_DEBUG "\tindex_size %u\n", | 370 | printk(KERN_DEBUG "\tindex_size %llu\n", |
368 | le32_to_cpu(mst->index_size)); | 371 | (unsigned long long)le64_to_cpu(mst->index_size)); |
369 | printk(KERN_DEBUG "\tlpt_lnum %u\n", | 372 | printk(KERN_DEBUG "\tlpt_lnum %u\n", |
370 | le32_to_cpu(mst->lpt_lnum)); | 373 | le32_to_cpu(mst->lpt_lnum)); |
371 | printk(KERN_DEBUG "\tlpt_offs %u\n", | 374 | printk(KERN_DEBUG "\tlpt_offs %u\n", |
@@ -1589,7 +1592,7 @@ static struct fsck_inode *add_inode(struct ubifs_info *c, | |||
1589 | 1592 | ||
1590 | if (inum > c->highest_inum) { | 1593 | if (inum > c->highest_inum) { |
1591 | ubifs_err("too high inode number, max. is %lu", | 1594 | ubifs_err("too high inode number, max. is %lu", |
1592 | c->highest_inum); | 1595 | (unsigned long)c->highest_inum); |
1593 | return ERR_PTR(-EINVAL); | 1596 | return ERR_PTR(-EINVAL); |
1594 | } | 1597 | } |
1595 | 1598 | ||
@@ -1668,16 +1671,18 @@ static struct fsck_inode *read_add_inode(struct ubifs_info *c, | |||
1668 | ino_key_init(c, &key, inum); | 1671 | ino_key_init(c, &key, inum); |
1669 | err = ubifs_lookup_level0(c, &key, &znode, &n); | 1672 | err = ubifs_lookup_level0(c, &key, &znode, &n); |
1670 | if (!err) { | 1673 | if (!err) { |
1671 | ubifs_err("inode %lu not found in index", inum); | 1674 | ubifs_err("inode %lu not found in index", (unsigned long)inum); |
1672 | return ERR_PTR(-ENOENT); | 1675 | return ERR_PTR(-ENOENT); |
1673 | } else if (err < 0) { | 1676 | } else if (err < 0) { |
1674 | ubifs_err("error %d while looking up inode %lu", err, inum); | 1677 | ubifs_err("error %d while looking up inode %lu", |
1678 | err, (unsigned long)inum); | ||
1675 | return ERR_PTR(err); | 1679 | return ERR_PTR(err); |
1676 | } | 1680 | } |
1677 | 1681 | ||
1678 | zbr = &znode->zbranch[n]; | 1682 | zbr = &znode->zbranch[n]; |
1679 | if (zbr->len < UBIFS_INO_NODE_SZ) { | 1683 | if (zbr->len < UBIFS_INO_NODE_SZ) { |
1680 | ubifs_err("bad node %lu node length %d", inum, zbr->len); | 1684 | ubifs_err("bad node %lu node length %d", |
1685 | (unsigned long)inum, zbr->len); | ||
1681 | return ERR_PTR(-EINVAL); | 1686 | return ERR_PTR(-EINVAL); |
1682 | } | 1687 | } |
1683 | 1688 | ||
@@ -1697,7 +1702,7 @@ static struct fsck_inode *read_add_inode(struct ubifs_info *c, | |||
1697 | kfree(ino); | 1702 | kfree(ino); |
1698 | if (IS_ERR(fscki)) { | 1703 | if (IS_ERR(fscki)) { |
1699 | ubifs_err("error %ld while adding inode %lu node", | 1704 | ubifs_err("error %ld while adding inode %lu node", |
1700 | PTR_ERR(fscki), inum); | 1705 | PTR_ERR(fscki), (unsigned long)inum); |
1701 | return fscki; | 1706 | return fscki; |
1702 | } | 1707 | } |
1703 | 1708 | ||
@@ -1786,7 +1791,8 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr, | |||
1786 | if (IS_ERR(fscki)) { | 1791 | if (IS_ERR(fscki)) { |
1787 | err = PTR_ERR(fscki); | 1792 | err = PTR_ERR(fscki); |
1788 | ubifs_err("error %d while processing data node and " | 1793 | ubifs_err("error %d while processing data node and " |
1789 | "trying to find inode node %lu", err, inum); | 1794 | "trying to find inode node %lu", |
1795 | err, (unsigned long)inum); | ||
1790 | goto out_dump; | 1796 | goto out_dump; |
1791 | } | 1797 | } |
1792 | 1798 | ||
@@ -1819,7 +1825,8 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr, | |||
1819 | if (IS_ERR(fscki)) { | 1825 | if (IS_ERR(fscki)) { |
1820 | err = PTR_ERR(fscki); | 1826 | err = PTR_ERR(fscki); |
1821 | ubifs_err("error %d while processing entry node and " | 1827 | ubifs_err("error %d while processing entry node and " |
1822 | "trying to find inode node %lu", err, inum); | 1828 | "trying to find inode node %lu", |
1829 | err, (unsigned long)inum); | ||
1823 | goto out_dump; | 1830 | goto out_dump; |
1824 | } | 1831 | } |
1825 | 1832 | ||
@@ -1832,7 +1839,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr, | |||
1832 | err = PTR_ERR(fscki); | 1839 | err = PTR_ERR(fscki); |
1833 | ubifs_err("error %d while processing entry node and " | 1840 | ubifs_err("error %d while processing entry node and " |
1834 | "trying to find parent inode node %lu", | 1841 | "trying to find parent inode node %lu", |
1835 | err, inum); | 1842 | err, (unsigned long)inum); |
1836 | goto out_dump; | 1843 | goto out_dump; |
1837 | } | 1844 | } |
1838 | 1845 | ||
@@ -1923,7 +1930,8 @@ static int check_inodes(struct ubifs_info *c, struct fsck_data *fsckd) | |||
1923 | fscki->references != 1) { | 1930 | fscki->references != 1) { |
1924 | ubifs_err("directory inode %lu has %d " | 1931 | ubifs_err("directory inode %lu has %d " |
1925 | "direntries which refer it, but " | 1932 | "direntries which refer it, but " |
1926 | "should be 1", fscki->inum, | 1933 | "should be 1", |
1934 | (unsigned long)fscki->inum, | ||
1927 | fscki->references); | 1935 | fscki->references); |
1928 | goto out_dump; | 1936 | goto out_dump; |
1929 | } | 1937 | } |
@@ -1931,27 +1939,29 @@ static int check_inodes(struct ubifs_info *c, struct fsck_data *fsckd) | |||
1931 | fscki->references != 0) { | 1939 | fscki->references != 0) { |
1932 | ubifs_err("root inode %lu has non-zero (%d) " | 1940 | ubifs_err("root inode %lu has non-zero (%d) " |
1933 | "direntries which refer it", | 1941 | "direntries which refer it", |
1934 | fscki->inum, fscki->references); | 1942 | (unsigned long)fscki->inum, |
1943 | fscki->references); | ||
1935 | goto out_dump; | 1944 | goto out_dump; |
1936 | } | 1945 | } |
1937 | if (fscki->calc_sz != fscki->size) { | 1946 | if (fscki->calc_sz != fscki->size) { |
1938 | ubifs_err("directory inode %lu size is %lld, " | 1947 | ubifs_err("directory inode %lu size is %lld, " |
1939 | "but calculated size is %lld", | 1948 | "but calculated size is %lld", |
1940 | fscki->inum, fscki->size, | 1949 | (unsigned long)fscki->inum, |
1941 | fscki->calc_sz); | 1950 | fscki->size, fscki->calc_sz); |
1942 | goto out_dump; | 1951 | goto out_dump; |
1943 | } | 1952 | } |
1944 | if (fscki->calc_cnt != fscki->nlink) { | 1953 | if (fscki->calc_cnt != fscki->nlink) { |
1945 | ubifs_err("directory inode %lu nlink is %d, " | 1954 | ubifs_err("directory inode %lu nlink is %d, " |
1946 | "but calculated nlink is %d", | 1955 | "but calculated nlink is %d", |
1947 | fscki->inum, fscki->nlink, | 1956 | (unsigned long)fscki->inum, |
1948 | fscki->calc_cnt); | 1957 | fscki->nlink, fscki->calc_cnt); |
1949 | goto out_dump; | 1958 | goto out_dump; |
1950 | } | 1959 | } |
1951 | } else { | 1960 | } else { |
1952 | if (fscki->references != fscki->nlink) { | 1961 | if (fscki->references != fscki->nlink) { |
1953 | ubifs_err("inode %lu nlink is %d, but " | 1962 | ubifs_err("inode %lu nlink is %d, but " |
1954 | "calculated nlink is %d", fscki->inum, | 1963 | "calculated nlink is %d", |
1964 | (unsigned long)fscki->inum, | ||
1955 | fscki->nlink, fscki->references); | 1965 | fscki->nlink, fscki->references); |
1956 | goto out_dump; | 1966 | goto out_dump; |
1957 | } | 1967 | } |
@@ -1959,20 +1969,21 @@ static int check_inodes(struct ubifs_info *c, struct fsck_data *fsckd) | |||
1959 | if (fscki->xattr_sz != fscki->calc_xsz) { | 1969 | if (fscki->xattr_sz != fscki->calc_xsz) { |
1960 | ubifs_err("inode %lu has xattr size %u, but " | 1970 | ubifs_err("inode %lu has xattr size %u, but " |
1961 | "calculated size is %lld", | 1971 | "calculated size is %lld", |
1962 | fscki->inum, fscki->xattr_sz, | 1972 | (unsigned long)fscki->inum, fscki->xattr_sz, |
1963 | fscki->calc_xsz); | 1973 | fscki->calc_xsz); |
1964 | goto out_dump; | 1974 | goto out_dump; |
1965 | } | 1975 | } |
1966 | if (fscki->xattr_cnt != fscki->calc_xcnt) { | 1976 | if (fscki->xattr_cnt != fscki->calc_xcnt) { |
1967 | ubifs_err("inode %lu has %u xattrs, but " | 1977 | ubifs_err("inode %lu has %u xattrs, but " |
1968 | "calculated count is %lld", fscki->inum, | 1978 | "calculated count is %lld", |
1979 | (unsigned long)fscki->inum, | ||
1969 | fscki->xattr_cnt, fscki->calc_xcnt); | 1980 | fscki->xattr_cnt, fscki->calc_xcnt); |
1970 | goto out_dump; | 1981 | goto out_dump; |
1971 | } | 1982 | } |
1972 | if (fscki->xattr_nms != fscki->calc_xnms) { | 1983 | if (fscki->xattr_nms != fscki->calc_xnms) { |
1973 | ubifs_err("inode %lu has xattr names' size %u, but " | 1984 | ubifs_err("inode %lu has xattr names' size %u, but " |
1974 | "calculated names' size is %lld", | 1985 | "calculated names' size is %lld", |
1975 | fscki->inum, fscki->xattr_nms, | 1986 | (unsigned long)fscki->inum, fscki->xattr_nms, |
1976 | fscki->calc_xnms); | 1987 | fscki->calc_xnms); |
1977 | goto out_dump; | 1988 | goto out_dump; |
1978 | } | 1989 | } |
@@ -1985,11 +1996,12 @@ out_dump: | |||
1985 | ino_key_init(c, &key, fscki->inum); | 1996 | ino_key_init(c, &key, fscki->inum); |
1986 | err = ubifs_lookup_level0(c, &key, &znode, &n); | 1997 | err = ubifs_lookup_level0(c, &key, &znode, &n); |
1987 | if (!err) { | 1998 | if (!err) { |
1988 | ubifs_err("inode %lu not found in index", fscki->inum); | 1999 | ubifs_err("inode %lu not found in index", |
2000 | (unsigned long)fscki->inum); | ||
1989 | return -ENOENT; | 2001 | return -ENOENT; |
1990 | } else if (err < 0) { | 2002 | } else if (err < 0) { |
1991 | ubifs_err("error %d while looking up inode %lu", | 2003 | ubifs_err("error %d while looking up inode %lu", |
1992 | err, fscki->inum); | 2004 | err, (unsigned long)fscki->inum); |
1993 | return err; | 2005 | return err; |
1994 | } | 2006 | } |
1995 | 2007 | ||
@@ -2007,7 +2019,7 @@ out_dump: | |||
2007 | } | 2019 | } |
2008 | 2020 | ||
2009 | ubifs_msg("dump of the inode %lu sitting in LEB %d:%d", | 2021 | ubifs_msg("dump of the inode %lu sitting in LEB %d:%d", |
2010 | fscki->inum, zbr->lnum, zbr->offs); | 2022 | (unsigned long)fscki->inum, zbr->lnum, zbr->offs); |
2011 | dbg_dump_node(c, ino); | 2023 | dbg_dump_node(c, ino); |
2012 | kfree(ino); | 2024 | kfree(ino); |
2013 | return -EINVAL; | 2025 | return -EINVAL; |
diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c index 526c01ec800..0422c98e179 100644 --- a/fs/ubifs/dir.c +++ b/fs/ubifs/dir.c | |||
@@ -161,7 +161,7 @@ struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir, | |||
161 | return ERR_PTR(-EINVAL); | 161 | return ERR_PTR(-EINVAL); |
162 | } | 162 | } |
163 | ubifs_warn("running out of inode numbers (current %lu, max %d)", | 163 | ubifs_warn("running out of inode numbers (current %lu, max %d)", |
164 | c->highest_inum, INUM_WATERMARK); | 164 | (unsigned long)c->highest_inum, INUM_WATERMARK); |
165 | } | 165 | } |
166 | 166 | ||
167 | inode->i_ino = ++c->highest_inum; | 167 | inode->i_ino = ++c->highest_inum; |
@@ -428,7 +428,8 @@ static int ubifs_readdir(struct file *file, void *dirent, filldir_t filldir) | |||
428 | dbg_gen("feed '%s', ino %llu, new f_pos %#x", | 428 | dbg_gen("feed '%s', ino %llu, new f_pos %#x", |
429 | dent->name, (unsigned long long)le64_to_cpu(dent->inum), | 429 | dent->name, (unsigned long long)le64_to_cpu(dent->inum), |
430 | key_hash_flash(c, &dent->key)); | 430 | key_hash_flash(c, &dent->key)); |
431 | ubifs_assert(dent->ch.sqnum > ubifs_inode(dir)->creat_sqnum); | 431 | ubifs_assert(le64_to_cpu(dent->ch.sqnum) > |
432 | ubifs_inode(dir)->creat_sqnum); | ||
432 | 433 | ||
433 | nm.len = le16_to_cpu(dent->nlen); | 434 | nm.len = le16_to_cpu(dent->nlen); |
434 | over = filldir(dirent, dent->name, nm.len, file->f_pos, | 435 | over = filldir(dirent, dent->name, nm.len, file->f_pos, |
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c index 51cf511d44d..2624411d975 100644 --- a/fs/ubifs/file.c +++ b/fs/ubifs/file.c | |||
@@ -72,7 +72,7 @@ static int read_block(struct inode *inode, void *addr, unsigned int block, | |||
72 | return err; | 72 | return err; |
73 | } | 73 | } |
74 | 74 | ||
75 | ubifs_assert(dn->ch.sqnum > ubifs_inode(inode)->creat_sqnum); | 75 | ubifs_assert(le64_to_cpu(dn->ch.sqnum) > ubifs_inode(inode)->creat_sqnum); |
76 | 76 | ||
77 | len = le32_to_cpu(dn->size); | 77 | len = le32_to_cpu(dn->size); |
78 | if (len <= 0 || len > UBIFS_BLOCK_SIZE) | 78 | if (len <= 0 || len > UBIFS_BLOCK_SIZE) |
@@ -626,7 +626,7 @@ static int populate_page(struct ubifs_info *c, struct page *page, | |||
626 | 626 | ||
627 | dn = bu->buf + (bu->zbranch[nn].offs - offs); | 627 | dn = bu->buf + (bu->zbranch[nn].offs - offs); |
628 | 628 | ||
629 | ubifs_assert(dn->ch.sqnum > | 629 | ubifs_assert(le64_to_cpu(dn->ch.sqnum) > |
630 | ubifs_inode(inode)->creat_sqnum); | 630 | ubifs_inode(inode)->creat_sqnum); |
631 | 631 | ||
632 | len = le32_to_cpu(dn->size); | 632 | len = le32_to_cpu(dn->size); |
@@ -691,32 +691,22 @@ out_err: | |||
691 | /** | 691 | /** |
692 | * ubifs_do_bulk_read - do bulk-read. | 692 | * ubifs_do_bulk_read - do bulk-read. |
693 | * @c: UBIFS file-system description object | 693 | * @c: UBIFS file-system description object |
694 | * @page1: first page | 694 | * @bu: bulk-read information |
695 | * @page1: first page to read | ||
695 | * | 696 | * |
696 | * This function returns %1 if the bulk-read is done, otherwise %0 is returned. | 697 | * This function returns %1 if the bulk-read is done, otherwise %0 is returned. |
697 | */ | 698 | */ |
698 | static int ubifs_do_bulk_read(struct ubifs_info *c, struct page *page1) | 699 | static int ubifs_do_bulk_read(struct ubifs_info *c, struct bu_info *bu, |
700 | struct page *page1) | ||
699 | { | 701 | { |
700 | pgoff_t offset = page1->index, end_index; | 702 | pgoff_t offset = page1->index, end_index; |
701 | struct address_space *mapping = page1->mapping; | 703 | struct address_space *mapping = page1->mapping; |
702 | struct inode *inode = mapping->host; | 704 | struct inode *inode = mapping->host; |
703 | struct ubifs_inode *ui = ubifs_inode(inode); | 705 | struct ubifs_inode *ui = ubifs_inode(inode); |
704 | struct bu_info *bu; | ||
705 | int err, page_idx, page_cnt, ret = 0, n = 0; | 706 | int err, page_idx, page_cnt, ret = 0, n = 0; |
707 | int allocate = bu->buf ? 0 : 1; | ||
706 | loff_t isize; | 708 | loff_t isize; |
707 | 709 | ||
708 | bu = kmalloc(sizeof(struct bu_info), GFP_NOFS); | ||
709 | if (!bu) | ||
710 | return 0; | ||
711 | |||
712 | bu->buf_len = c->bulk_read_buf_size; | ||
713 | bu->buf = kmalloc(bu->buf_len, GFP_NOFS); | ||
714 | if (!bu->buf) | ||
715 | goto out_free; | ||
716 | |||
717 | data_key_init(c, &bu->key, inode->i_ino, | ||
718 | offset << UBIFS_BLOCKS_PER_PAGE_SHIFT); | ||
719 | |||
720 | err = ubifs_tnc_get_bu_keys(c, bu); | 710 | err = ubifs_tnc_get_bu_keys(c, bu); |
721 | if (err) | 711 | if (err) |
722 | goto out_warn; | 712 | goto out_warn; |
@@ -735,12 +725,25 @@ static int ubifs_do_bulk_read(struct ubifs_info *c, struct page *page1) | |||
735 | * together. If all the pages were like this, bulk-read would | 725 | * together. If all the pages were like this, bulk-read would |
736 | * reduce performance, so we turn it off for a while. | 726 | * reduce performance, so we turn it off for a while. |
737 | */ | 727 | */ |
738 | ui->read_in_a_row = 0; | 728 | goto out_bu_off; |
739 | ui->bulk_read = 0; | ||
740 | goto out_free; | ||
741 | } | 729 | } |
742 | 730 | ||
743 | if (bu->cnt) { | 731 | if (bu->cnt) { |
732 | if (allocate) { | ||
733 | /* | ||
734 | * Allocate bulk-read buffer depending on how many data | ||
735 | * nodes we are going to read. | ||
736 | */ | ||
737 | bu->buf_len = bu->zbranch[bu->cnt - 1].offs + | ||
738 | bu->zbranch[bu->cnt - 1].len - | ||
739 | bu->zbranch[0].offs; | ||
740 | ubifs_assert(bu->buf_len > 0); | ||
741 | ubifs_assert(bu->buf_len <= c->leb_size); | ||
742 | bu->buf = kmalloc(bu->buf_len, GFP_NOFS | __GFP_NOWARN); | ||
743 | if (!bu->buf) | ||
744 | goto out_bu_off; | ||
745 | } | ||
746 | |||
744 | err = ubifs_tnc_bulk_read(c, bu); | 747 | err = ubifs_tnc_bulk_read(c, bu); |
745 | if (err) | 748 | if (err) |
746 | goto out_warn; | 749 | goto out_warn; |
@@ -779,13 +782,17 @@ static int ubifs_do_bulk_read(struct ubifs_info *c, struct page *page1) | |||
779 | ui->last_page_read = offset + page_idx - 1; | 782 | ui->last_page_read = offset + page_idx - 1; |
780 | 783 | ||
781 | out_free: | 784 | out_free: |
782 | kfree(bu->buf); | 785 | if (allocate) |
783 | kfree(bu); | 786 | kfree(bu->buf); |
784 | return ret; | 787 | return ret; |
785 | 788 | ||
786 | out_warn: | 789 | out_warn: |
787 | ubifs_warn("ignoring error %d and skipping bulk-read", err); | 790 | ubifs_warn("ignoring error %d and skipping bulk-read", err); |
788 | goto out_free; | 791 | goto out_free; |
792 | |||
793 | out_bu_off: | ||
794 | ui->read_in_a_row = ui->bulk_read = 0; | ||
795 | goto out_free; | ||
789 | } | 796 | } |
790 | 797 | ||
791 | /** | 798 | /** |
@@ -803,18 +810,20 @@ static int ubifs_bulk_read(struct page *page) | |||
803 | struct ubifs_info *c = inode->i_sb->s_fs_info; | 810 | struct ubifs_info *c = inode->i_sb->s_fs_info; |
804 | struct ubifs_inode *ui = ubifs_inode(inode); | 811 | struct ubifs_inode *ui = ubifs_inode(inode); |
805 | pgoff_t index = page->index, last_page_read = ui->last_page_read; | 812 | pgoff_t index = page->index, last_page_read = ui->last_page_read; |
806 | int ret = 0; | 813 | struct bu_info *bu; |
814 | int err = 0, allocated = 0; | ||
807 | 815 | ||
808 | ui->last_page_read = index; | 816 | ui->last_page_read = index; |
809 | |||
810 | if (!c->bulk_read) | 817 | if (!c->bulk_read) |
811 | return 0; | 818 | return 0; |
819 | |||
812 | /* | 820 | /* |
813 | * Bulk-read is protected by ui_mutex, but it is an optimization, so | 821 | * Bulk-read is protected by @ui->ui_mutex, but it is an optimization, |
814 | * don't bother if we cannot lock the mutex. | 822 | * so don't bother if we cannot lock the mutex. |
815 | */ | 823 | */ |
816 | if (!mutex_trylock(&ui->ui_mutex)) | 824 | if (!mutex_trylock(&ui->ui_mutex)) |
817 | return 0; | 825 | return 0; |
826 | |||
818 | if (index != last_page_read + 1) { | 827 | if (index != last_page_read + 1) { |
819 | /* Turn off bulk-read if we stop reading sequentially */ | 828 | /* Turn off bulk-read if we stop reading sequentially */ |
820 | ui->read_in_a_row = 1; | 829 | ui->read_in_a_row = 1; |
@@ -822,6 +831,7 @@ static int ubifs_bulk_read(struct page *page) | |||
822 | ui->bulk_read = 0; | 831 | ui->bulk_read = 0; |
823 | goto out_unlock; | 832 | goto out_unlock; |
824 | } | 833 | } |
834 | |||
825 | if (!ui->bulk_read) { | 835 | if (!ui->bulk_read) { |
826 | ui->read_in_a_row += 1; | 836 | ui->read_in_a_row += 1; |
827 | if (ui->read_in_a_row < 3) | 837 | if (ui->read_in_a_row < 3) |
@@ -829,10 +839,35 @@ static int ubifs_bulk_read(struct page *page) | |||
829 | /* Three reads in a row, so switch on bulk-read */ | 839 | /* Three reads in a row, so switch on bulk-read */ |
830 | ui->bulk_read = 1; | 840 | ui->bulk_read = 1; |
831 | } | 841 | } |
832 | ret = ubifs_do_bulk_read(c, page); | 842 | |
843 | /* | ||
844 | * If possible, try to use pre-allocated bulk-read information, which | ||
845 | * is protected by @c->bu_mutex. | ||
846 | */ | ||
847 | if (mutex_trylock(&c->bu_mutex)) | ||
848 | bu = &c->bu; | ||
849 | else { | ||
850 | bu = kmalloc(sizeof(struct bu_info), GFP_NOFS | __GFP_NOWARN); | ||
851 | if (!bu) | ||
852 | goto out_unlock; | ||
853 | |||
854 | bu->buf = NULL; | ||
855 | allocated = 1; | ||
856 | } | ||
857 | |||
858 | bu->buf_len = c->max_bu_buf_len; | ||
859 | data_key_init(c, &bu->key, inode->i_ino, | ||
860 | page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT); | ||
861 | err = ubifs_do_bulk_read(c, bu, page); | ||
862 | |||
863 | if (!allocated) | ||
864 | mutex_unlock(&c->bu_mutex); | ||
865 | else | ||
866 | kfree(bu); | ||
867 | |||
833 | out_unlock: | 868 | out_unlock: |
834 | mutex_unlock(&ui->ui_mutex); | 869 | mutex_unlock(&ui->ui_mutex); |
835 | return ret; | 870 | return err; |
836 | } | 871 | } |
837 | 872 | ||
838 | static int ubifs_readpage(struct file *file, struct page *page) | 873 | static int ubifs_readpage(struct file *file, struct page *page) |
diff --git a/fs/ubifs/journal.c b/fs/ubifs/journal.c index 22993f867d1..f91b745908e 100644 --- a/fs/ubifs/journal.c +++ b/fs/ubifs/journal.c | |||
@@ -690,8 +690,9 @@ int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode, | |||
690 | int dlen = UBIFS_DATA_NODE_SZ + UBIFS_BLOCK_SIZE * WORST_COMPR_FACTOR; | 690 | int dlen = UBIFS_DATA_NODE_SZ + UBIFS_BLOCK_SIZE * WORST_COMPR_FACTOR; |
691 | struct ubifs_inode *ui = ubifs_inode(inode); | 691 | struct ubifs_inode *ui = ubifs_inode(inode); |
692 | 692 | ||
693 | dbg_jnl("ino %lu, blk %u, len %d, key %s", key_inum(c, key), | 693 | dbg_jnl("ino %lu, blk %u, len %d, key %s", |
694 | key_block(c, key), len, DBGKEY(key)); | 694 | (unsigned long)key_inum(c, key), key_block(c, key), len, |
695 | DBGKEY(key)); | ||
695 | ubifs_assert(len <= UBIFS_BLOCK_SIZE); | 696 | ubifs_assert(len <= UBIFS_BLOCK_SIZE); |
696 | 697 | ||
697 | data = kmalloc(dlen, GFP_NOFS); | 698 | data = kmalloc(dlen, GFP_NOFS); |
@@ -1128,7 +1129,8 @@ int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode, | |||
1128 | ino_t inum = inode->i_ino; | 1129 | ino_t inum = inode->i_ino; |
1129 | unsigned int blk; | 1130 | unsigned int blk; |
1130 | 1131 | ||
1131 | dbg_jnl("ino %lu, size %lld -> %lld", inum, old_size, new_size); | 1132 | dbg_jnl("ino %lu, size %lld -> %lld", |
1133 | (unsigned long)inum, old_size, new_size); | ||
1132 | ubifs_assert(!ui->data_len); | 1134 | ubifs_assert(!ui->data_len); |
1133 | ubifs_assert(S_ISREG(inode->i_mode)); | 1135 | ubifs_assert(S_ISREG(inode->i_mode)); |
1134 | ubifs_assert(mutex_is_locked(&ui->ui_mutex)); | 1136 | ubifs_assert(mutex_is_locked(&ui->ui_mutex)); |
diff --git a/fs/ubifs/key.h b/fs/ubifs/key.h index 9ee65086f62..3f1f16bc25c 100644 --- a/fs/ubifs/key.h +++ b/fs/ubifs/key.h | |||
@@ -345,7 +345,7 @@ static inline int key_type_flash(const struct ubifs_info *c, const void *k) | |||
345 | { | 345 | { |
346 | const union ubifs_key *key = k; | 346 | const union ubifs_key *key = k; |
347 | 347 | ||
348 | return le32_to_cpu(key->u32[1]) >> UBIFS_S_KEY_BLOCK_BITS; | 348 | return le32_to_cpu(key->j32[1]) >> UBIFS_S_KEY_BLOCK_BITS; |
349 | } | 349 | } |
350 | 350 | ||
351 | /** | 351 | /** |
@@ -416,7 +416,7 @@ static inline unsigned int key_block_flash(const struct ubifs_info *c, | |||
416 | { | 416 | { |
417 | const union ubifs_key *key = k; | 417 | const union ubifs_key *key = k; |
418 | 418 | ||
419 | return le32_to_cpu(key->u32[1]) & UBIFS_S_KEY_BLOCK_MASK; | 419 | return le32_to_cpu(key->j32[1]) & UBIFS_S_KEY_BLOCK_MASK; |
420 | } | 420 | } |
421 | 421 | ||
422 | /** | 422 | /** |
diff --git a/fs/ubifs/lpt_commit.c b/fs/ubifs/lpt_commit.c index eed5a0025d6..a41434b4278 100644 --- a/fs/ubifs/lpt_commit.c +++ b/fs/ubifs/lpt_commit.c | |||
@@ -571,8 +571,6 @@ static struct ubifs_pnode *next_pnode(struct ubifs_info *c, | |||
571 | /* We assume here that LEB zero is never an LPT LEB */ | 571 | /* We assume here that LEB zero is never an LPT LEB */ |
572 | if (nnode->nbranch[iip].lnum) | 572 | if (nnode->nbranch[iip].lnum) |
573 | return ubifs_get_pnode(c, nnode, iip); | 573 | return ubifs_get_pnode(c, nnode, iip); |
574 | else | ||
575 | return NULL; | ||
576 | } | 574 | } |
577 | 575 | ||
578 | /* Go up while can't go right */ | 576 | /* Go up while can't go right */ |
diff --git a/fs/ubifs/orphan.c b/fs/ubifs/orphan.c index 02d3462f4d3..9bd5a43d452 100644 --- a/fs/ubifs/orphan.c +++ b/fs/ubifs/orphan.c | |||
@@ -105,7 +105,7 @@ int ubifs_add_orphan(struct ubifs_info *c, ino_t inum) | |||
105 | list_add_tail(&orphan->list, &c->orph_list); | 105 | list_add_tail(&orphan->list, &c->orph_list); |
106 | list_add_tail(&orphan->new_list, &c->orph_new); | 106 | list_add_tail(&orphan->new_list, &c->orph_new); |
107 | spin_unlock(&c->orphan_lock); | 107 | spin_unlock(&c->orphan_lock); |
108 | dbg_gen("ino %lu", inum); | 108 | dbg_gen("ino %lu", (unsigned long)inum); |
109 | return 0; | 109 | return 0; |
110 | } | 110 | } |
111 | 111 | ||
@@ -132,14 +132,16 @@ void ubifs_delete_orphan(struct ubifs_info *c, ino_t inum) | |||
132 | else { | 132 | else { |
133 | if (o->dnext) { | 133 | if (o->dnext) { |
134 | spin_unlock(&c->orphan_lock); | 134 | spin_unlock(&c->orphan_lock); |
135 | dbg_gen("deleted twice ino %lu", inum); | 135 | dbg_gen("deleted twice ino %lu", |
136 | (unsigned long)inum); | ||
136 | return; | 137 | return; |
137 | } | 138 | } |
138 | if (o->cnext) { | 139 | if (o->cnext) { |
139 | o->dnext = c->orph_dnext; | 140 | o->dnext = c->orph_dnext; |
140 | c->orph_dnext = o; | 141 | c->orph_dnext = o; |
141 | spin_unlock(&c->orphan_lock); | 142 | spin_unlock(&c->orphan_lock); |
142 | dbg_gen("delete later ino %lu", inum); | 143 | dbg_gen("delete later ino %lu", |
144 | (unsigned long)inum); | ||
143 | return; | 145 | return; |
144 | } | 146 | } |
145 | rb_erase(p, &c->orph_tree); | 147 | rb_erase(p, &c->orph_tree); |
@@ -151,12 +153,12 @@ void ubifs_delete_orphan(struct ubifs_info *c, ino_t inum) | |||
151 | } | 153 | } |
152 | spin_unlock(&c->orphan_lock); | 154 | spin_unlock(&c->orphan_lock); |
153 | kfree(o); | 155 | kfree(o); |
154 | dbg_gen("inum %lu", inum); | 156 | dbg_gen("inum %lu", (unsigned long)inum); |
155 | return; | 157 | return; |
156 | } | 158 | } |
157 | } | 159 | } |
158 | spin_unlock(&c->orphan_lock); | 160 | spin_unlock(&c->orphan_lock); |
159 | dbg_err("missing orphan ino %lu", inum); | 161 | dbg_err("missing orphan ino %lu", (unsigned long)inum); |
160 | dbg_dump_stack(); | 162 | dbg_dump_stack(); |
161 | } | 163 | } |
162 | 164 | ||
@@ -448,7 +450,7 @@ static void erase_deleted(struct ubifs_info *c) | |||
448 | rb_erase(&orphan->rb, &c->orph_tree); | 450 | rb_erase(&orphan->rb, &c->orph_tree); |
449 | list_del(&orphan->list); | 451 | list_del(&orphan->list); |
450 | c->tot_orphans -= 1; | 452 | c->tot_orphans -= 1; |
451 | dbg_gen("deleting orphan ino %lu", orphan->inum); | 453 | dbg_gen("deleting orphan ino %lu", (unsigned long)orphan->inum); |
452 | kfree(orphan); | 454 | kfree(orphan); |
453 | } | 455 | } |
454 | c->orph_dnext = NULL; | 456 | c->orph_dnext = NULL; |
@@ -536,8 +538,8 @@ static int insert_dead_orphan(struct ubifs_info *c, ino_t inum) | |||
536 | list_add_tail(&orphan->list, &c->orph_list); | 538 | list_add_tail(&orphan->list, &c->orph_list); |
537 | orphan->dnext = c->orph_dnext; | 539 | orphan->dnext = c->orph_dnext; |
538 | c->orph_dnext = orphan; | 540 | c->orph_dnext = orphan; |
539 | dbg_mnt("ino %lu, new %d, tot %d", | 541 | dbg_mnt("ino %lu, new %d, tot %d", (unsigned long)inum, |
540 | inum, c->new_orphans, c->tot_orphans); | 542 | c->new_orphans, c->tot_orphans); |
541 | return 0; | 543 | return 0; |
542 | } | 544 | } |
543 | 545 | ||
@@ -609,7 +611,8 @@ static int do_kill_orphans(struct ubifs_info *c, struct ubifs_scan_leb *sleb, | |||
609 | n = (le32_to_cpu(orph->ch.len) - UBIFS_ORPH_NODE_SZ) >> 3; | 611 | n = (le32_to_cpu(orph->ch.len) - UBIFS_ORPH_NODE_SZ) >> 3; |
610 | for (i = 0; i < n; i++) { | 612 | for (i = 0; i < n; i++) { |
611 | inum = le64_to_cpu(orph->inos[i]); | 613 | inum = le64_to_cpu(orph->inos[i]); |
612 | dbg_rcvry("deleting orphaned inode %lu", inum); | 614 | dbg_rcvry("deleting orphaned inode %lu", |
615 | (unsigned long)inum); | ||
613 | err = ubifs_tnc_remove_ino(c, inum); | 616 | err = ubifs_tnc_remove_ino(c, inum); |
614 | if (err) | 617 | if (err) |
615 | return err; | 618 | return err; |
@@ -840,8 +843,8 @@ static int dbg_orphan_check(struct ubifs_info *c, struct ubifs_zbranch *zbr, | |||
840 | if (inum != ci->last_ino) { | 843 | if (inum != ci->last_ino) { |
841 | /* Lowest node type is the inode node, so it comes first */ | 844 | /* Lowest node type is the inode node, so it comes first */ |
842 | if (key_type(c, &zbr->key) != UBIFS_INO_KEY) | 845 | if (key_type(c, &zbr->key) != UBIFS_INO_KEY) |
843 | ubifs_err("found orphan node ino %lu, type %d", inum, | 846 | ubifs_err("found orphan node ino %lu, type %d", |
844 | key_type(c, &zbr->key)); | 847 | (unsigned long)inum, key_type(c, &zbr->key)); |
845 | ci->last_ino = inum; | 848 | ci->last_ino = inum; |
846 | ci->tot_inos += 1; | 849 | ci->tot_inos += 1; |
847 | err = ubifs_tnc_read_node(c, zbr, ci->node); | 850 | err = ubifs_tnc_read_node(c, zbr, ci->node); |
@@ -853,7 +856,8 @@ static int dbg_orphan_check(struct ubifs_info *c, struct ubifs_zbranch *zbr, | |||
853 | /* Must be recorded as an orphan */ | 856 | /* Must be recorded as an orphan */ |
854 | if (!dbg_find_check_orphan(&ci->root, inum) && | 857 | if (!dbg_find_check_orphan(&ci->root, inum) && |
855 | !dbg_find_orphan(c, inum)) { | 858 | !dbg_find_orphan(c, inum)) { |
856 | ubifs_err("missing orphan, ino %lu", inum); | 859 | ubifs_err("missing orphan, ino %lu", |
860 | (unsigned long)inum); | ||
857 | ci->missing += 1; | 861 | ci->missing += 1; |
858 | } | 862 | } |
859 | } | 863 | } |
diff --git a/fs/ubifs/recovery.c b/fs/ubifs/recovery.c index 77d26c141cf..90acac603e6 100644 --- a/fs/ubifs/recovery.c +++ b/fs/ubifs/recovery.c | |||
@@ -168,12 +168,12 @@ static int write_rcvrd_mst_node(struct ubifs_info *c, | |||
168 | struct ubifs_mst_node *mst) | 168 | struct ubifs_mst_node *mst) |
169 | { | 169 | { |
170 | int err = 0, lnum = UBIFS_MST_LNUM, sz = c->mst_node_alsz; | 170 | int err = 0, lnum = UBIFS_MST_LNUM, sz = c->mst_node_alsz; |
171 | uint32_t save_flags; | 171 | __le32 save_flags; |
172 | 172 | ||
173 | dbg_rcvry("recovery"); | 173 | dbg_rcvry("recovery"); |
174 | 174 | ||
175 | save_flags = mst->flags; | 175 | save_flags = mst->flags; |
176 | mst->flags = cpu_to_le32(le32_to_cpu(mst->flags) | UBIFS_MST_RCVRY); | 176 | mst->flags |= cpu_to_le32(UBIFS_MST_RCVRY); |
177 | 177 | ||
178 | ubifs_prepare_node(c, mst, UBIFS_MST_NODE_SZ, 1); | 178 | ubifs_prepare_node(c, mst, UBIFS_MST_NODE_SZ, 1); |
179 | err = ubi_leb_change(c->ubi, lnum, mst, sz, UBI_SHORTTERM); | 179 | err = ubi_leb_change(c->ubi, lnum, mst, sz, UBI_SHORTTERM); |
@@ -1435,13 +1435,13 @@ static int fix_size_in_place(struct ubifs_info *c, struct size_entry *e) | |||
1435 | err = ubi_leb_change(c->ubi, lnum, c->sbuf, len, UBI_UNKNOWN); | 1435 | err = ubi_leb_change(c->ubi, lnum, c->sbuf, len, UBI_UNKNOWN); |
1436 | if (err) | 1436 | if (err) |
1437 | goto out; | 1437 | goto out; |
1438 | dbg_rcvry("inode %lu at %d:%d size %lld -> %lld ", e->inum, lnum, offs, | 1438 | dbg_rcvry("inode %lu at %d:%d size %lld -> %lld ", |
1439 | i_size, e->d_size); | 1439 | (unsigned long)e->inum, lnum, offs, i_size, e->d_size); |
1440 | return 0; | 1440 | return 0; |
1441 | 1441 | ||
1442 | out: | 1442 | out: |
1443 | ubifs_warn("inode %lu failed to fix size %lld -> %lld error %d", | 1443 | ubifs_warn("inode %lu failed to fix size %lld -> %lld error %d", |
1444 | e->inum, e->i_size, e->d_size, err); | 1444 | (unsigned long)e->inum, e->i_size, e->d_size, err); |
1445 | return err; | 1445 | return err; |
1446 | } | 1446 | } |
1447 | 1447 | ||
@@ -1472,7 +1472,8 @@ int ubifs_recover_size(struct ubifs_info *c) | |||
1472 | return err; | 1472 | return err; |
1473 | if (err == -ENOENT) { | 1473 | if (err == -ENOENT) { |
1474 | /* Remove data nodes that have no inode */ | 1474 | /* Remove data nodes that have no inode */ |
1475 | dbg_rcvry("removing ino %lu", e->inum); | 1475 | dbg_rcvry("removing ino %lu", |
1476 | (unsigned long)e->inum); | ||
1476 | err = ubifs_tnc_remove_ino(c, e->inum); | 1477 | err = ubifs_tnc_remove_ino(c, e->inum); |
1477 | if (err) | 1478 | if (err) |
1478 | return err; | 1479 | return err; |
@@ -1493,8 +1494,8 @@ int ubifs_recover_size(struct ubifs_info *c) | |||
1493 | return PTR_ERR(inode); | 1494 | return PTR_ERR(inode); |
1494 | if (inode->i_size < e->d_size) { | 1495 | if (inode->i_size < e->d_size) { |
1495 | dbg_rcvry("ino %lu size %lld -> %lld", | 1496 | dbg_rcvry("ino %lu size %lld -> %lld", |
1496 | e->inum, e->d_size, | 1497 | (unsigned long)e->inum, |
1497 | inode->i_size); | 1498 | e->d_size, inode->i_size); |
1498 | inode->i_size = e->d_size; | 1499 | inode->i_size = e->d_size; |
1499 | ubifs_inode(inode)->ui_size = e->d_size; | 1500 | ubifs_inode(inode)->ui_size = e->d_size; |
1500 | e->inode = inode; | 1501 | e->inode = inode; |
diff --git a/fs/ubifs/replay.c b/fs/ubifs/replay.c index 7399692af85..21f7d047c30 100644 --- a/fs/ubifs/replay.c +++ b/fs/ubifs/replay.c | |||
@@ -1065,7 +1065,7 @@ int ubifs_replay_journal(struct ubifs_info *c) | |||
1065 | ubifs_assert(c->bud_bytes <= c->max_bud_bytes || c->need_recovery); | 1065 | ubifs_assert(c->bud_bytes <= c->max_bud_bytes || c->need_recovery); |
1066 | dbg_mnt("finished, log head LEB %d:%d, max_sqnum %llu, " | 1066 | dbg_mnt("finished, log head LEB %d:%d, max_sqnum %llu, " |
1067 | "highest_inum %lu", c->lhead_lnum, c->lhead_offs, c->max_sqnum, | 1067 | "highest_inum %lu", c->lhead_lnum, c->lhead_offs, c->max_sqnum, |
1068 | c->highest_inum); | 1068 | (unsigned long)c->highest_inum); |
1069 | out: | 1069 | out: |
1070 | destroy_replay_tree(c); | 1070 | destroy_replay_tree(c); |
1071 | destroy_bud_list(c); | 1071 | destroy_bud_list(c); |
diff --git a/fs/ubifs/sb.c b/fs/ubifs/sb.c index 2bf753b3888..0f392351dc5 100644 --- a/fs/ubifs/sb.c +++ b/fs/ubifs/sb.c | |||
@@ -81,6 +81,7 @@ static int create_default_filesystem(struct ubifs_info *c) | |||
81 | int lpt_lebs, lpt_first, orph_lebs, big_lpt, ino_waste, sup_flags = 0; | 81 | int lpt_lebs, lpt_first, orph_lebs, big_lpt, ino_waste, sup_flags = 0; |
82 | int min_leb_cnt = UBIFS_MIN_LEB_CNT; | 82 | int min_leb_cnt = UBIFS_MIN_LEB_CNT; |
83 | uint64_t tmp64, main_bytes; | 83 | uint64_t tmp64, main_bytes; |
84 | __le64 tmp_le64; | ||
84 | 85 | ||
85 | /* Some functions called from here depend on the @c->key_len filed */ | 86 | /* Some functions called from here depend on the @c->key_len filed */ |
86 | c->key_len = UBIFS_SK_LEN; | 87 | c->key_len = UBIFS_SK_LEN; |
@@ -295,10 +296,10 @@ static int create_default_filesystem(struct ubifs_info *c) | |||
295 | ino->ch.node_type = UBIFS_INO_NODE; | 296 | ino->ch.node_type = UBIFS_INO_NODE; |
296 | ino->creat_sqnum = cpu_to_le64(++c->max_sqnum); | 297 | ino->creat_sqnum = cpu_to_le64(++c->max_sqnum); |
297 | ino->nlink = cpu_to_le32(2); | 298 | ino->nlink = cpu_to_le32(2); |
298 | tmp = cpu_to_le64(CURRENT_TIME_SEC.tv_sec); | 299 | tmp_le64 = cpu_to_le64(CURRENT_TIME_SEC.tv_sec); |
299 | ino->atime_sec = tmp; | 300 | ino->atime_sec = tmp_le64; |
300 | ino->ctime_sec = tmp; | 301 | ino->ctime_sec = tmp_le64; |
301 | ino->mtime_sec = tmp; | 302 | ino->mtime_sec = tmp_le64; |
302 | ino->atime_nsec = 0; | 303 | ino->atime_nsec = 0; |
303 | ino->ctime_nsec = 0; | 304 | ino->ctime_nsec = 0; |
304 | ino->mtime_nsec = 0; | 305 | ino->mtime_nsec = 0; |
diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c index 8780efbf40a..d80b2aef42b 100644 --- a/fs/ubifs/super.c +++ b/fs/ubifs/super.c | |||
@@ -36,6 +36,12 @@ | |||
36 | #include <linux/mount.h> | 36 | #include <linux/mount.h> |
37 | #include "ubifs.h" | 37 | #include "ubifs.h" |
38 | 38 | ||
39 | /* | ||
40 | * Maximum amount of memory we may 'kmalloc()' without worrying that we are | ||
41 | * allocating too much. | ||
42 | */ | ||
43 | #define UBIFS_KMALLOC_OK (128*1024) | ||
44 | |||
39 | /* Slab cache for UBIFS inodes */ | 45 | /* Slab cache for UBIFS inodes */ |
40 | struct kmem_cache *ubifs_inode_slab; | 46 | struct kmem_cache *ubifs_inode_slab; |
41 | 47 | ||
@@ -561,18 +567,11 @@ static int init_constants_early(struct ubifs_info *c) | |||
561 | * calculations when reporting free space. | 567 | * calculations when reporting free space. |
562 | */ | 568 | */ |
563 | c->leb_overhead = c->leb_size % UBIFS_MAX_DATA_NODE_SZ; | 569 | c->leb_overhead = c->leb_size % UBIFS_MAX_DATA_NODE_SZ; |
564 | /* Buffer size for bulk-reads */ | ||
565 | c->bulk_read_buf_size = UBIFS_MAX_BULK_READ * UBIFS_MAX_DATA_NODE_SZ; | ||
566 | if (c->bulk_read_buf_size > c->leb_size) | ||
567 | c->bulk_read_buf_size = c->leb_size; | ||
568 | if (c->bulk_read_buf_size > 128 * 1024) { | ||
569 | /* Check if we can kmalloc more than 128KiB */ | ||
570 | void *try = kmalloc(c->bulk_read_buf_size, GFP_KERNEL); | ||
571 | 570 | ||
572 | kfree(try); | 571 | /* Buffer size for bulk-reads */ |
573 | if (!try) | 572 | c->max_bu_buf_len = UBIFS_MAX_BULK_READ * UBIFS_MAX_DATA_NODE_SZ; |
574 | c->bulk_read_buf_size = 128 * 1024; | 573 | if (c->max_bu_buf_len > c->leb_size) |
575 | } | 574 | c->max_bu_buf_len = c->leb_size; |
576 | return 0; | 575 | return 0; |
577 | } | 576 | } |
578 | 577 | ||
@@ -992,6 +991,34 @@ static void destroy_journal(struct ubifs_info *c) | |||
992 | } | 991 | } |
993 | 992 | ||
994 | /** | 993 | /** |
994 | * bu_init - initialize bulk-read information. | ||
995 | * @c: UBIFS file-system description object | ||
996 | */ | ||
997 | static void bu_init(struct ubifs_info *c) | ||
998 | { | ||
999 | ubifs_assert(c->bulk_read == 1); | ||
1000 | |||
1001 | if (c->bu.buf) | ||
1002 | return; /* Already initialized */ | ||
1003 | |||
1004 | again: | ||
1005 | c->bu.buf = kmalloc(c->max_bu_buf_len, GFP_KERNEL | __GFP_NOWARN); | ||
1006 | if (!c->bu.buf) { | ||
1007 | if (c->max_bu_buf_len > UBIFS_KMALLOC_OK) { | ||
1008 | c->max_bu_buf_len = UBIFS_KMALLOC_OK; | ||
1009 | goto again; | ||
1010 | } | ||
1011 | |||
1012 | /* Just disable bulk-read */ | ||
1013 | ubifs_warn("Cannot allocate %d bytes of memory for bulk-read, " | ||
1014 | "disabling it", c->max_bu_buf_len); | ||
1015 | c->mount_opts.bulk_read = 1; | ||
1016 | c->bulk_read = 0; | ||
1017 | return; | ||
1018 | } | ||
1019 | } | ||
1020 | |||
1021 | /** | ||
995 | * mount_ubifs - mount UBIFS file-system. | 1022 | * mount_ubifs - mount UBIFS file-system. |
996 | * @c: UBIFS file-system description object | 1023 | * @c: UBIFS file-system description object |
997 | * | 1024 | * |
@@ -1059,6 +1086,13 @@ static int mount_ubifs(struct ubifs_info *c) | |||
1059 | goto out_free; | 1086 | goto out_free; |
1060 | } | 1087 | } |
1061 | 1088 | ||
1089 | if (c->bulk_read == 1) | ||
1090 | bu_init(c); | ||
1091 | |||
1092 | /* | ||
1093 | * We have to check all CRCs, even for data nodes, when we mount the FS | ||
1094 | * (specifically, when we are replaying). | ||
1095 | */ | ||
1062 | c->always_chk_crc = 1; | 1096 | c->always_chk_crc = 1; |
1063 | 1097 | ||
1064 | err = ubifs_read_superblock(c); | 1098 | err = ubifs_read_superblock(c); |
@@ -1289,6 +1323,7 @@ out_cbuf: | |||
1289 | out_dereg: | 1323 | out_dereg: |
1290 | dbg_failure_mode_deregistration(c); | 1324 | dbg_failure_mode_deregistration(c); |
1291 | out_free: | 1325 | out_free: |
1326 | kfree(c->bu.buf); | ||
1292 | vfree(c->ileb_buf); | 1327 | vfree(c->ileb_buf); |
1293 | vfree(c->sbuf); | 1328 | vfree(c->sbuf); |
1294 | kfree(c->bottom_up_buf); | 1329 | kfree(c->bottom_up_buf); |
@@ -1325,10 +1360,11 @@ static void ubifs_umount(struct ubifs_info *c) | |||
1325 | kfree(c->cbuf); | 1360 | kfree(c->cbuf); |
1326 | kfree(c->rcvrd_mst_node); | 1361 | kfree(c->rcvrd_mst_node); |
1327 | kfree(c->mst_node); | 1362 | kfree(c->mst_node); |
1363 | kfree(c->bu.buf); | ||
1364 | vfree(c->ileb_buf); | ||
1328 | vfree(c->sbuf); | 1365 | vfree(c->sbuf); |
1329 | kfree(c->bottom_up_buf); | 1366 | kfree(c->bottom_up_buf); |
1330 | UBIFS_DBG(vfree(c->dbg_buf)); | 1367 | UBIFS_DBG(vfree(c->dbg_buf)); |
1331 | vfree(c->ileb_buf); | ||
1332 | dbg_failure_mode_deregistration(c); | 1368 | dbg_failure_mode_deregistration(c); |
1333 | } | 1369 | } |
1334 | 1370 | ||
@@ -1626,6 +1662,7 @@ static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data) | |||
1626 | ubifs_err("invalid or unknown remount parameter"); | 1662 | ubifs_err("invalid or unknown remount parameter"); |
1627 | return err; | 1663 | return err; |
1628 | } | 1664 | } |
1665 | |||
1629 | if ((sb->s_flags & MS_RDONLY) && !(*flags & MS_RDONLY)) { | 1666 | if ((sb->s_flags & MS_RDONLY) && !(*flags & MS_RDONLY)) { |
1630 | err = ubifs_remount_rw(c); | 1667 | err = ubifs_remount_rw(c); |
1631 | if (err) | 1668 | if (err) |
@@ -1633,6 +1670,14 @@ static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data) | |||
1633 | } else if (!(sb->s_flags & MS_RDONLY) && (*flags & MS_RDONLY)) | 1670 | } else if (!(sb->s_flags & MS_RDONLY) && (*flags & MS_RDONLY)) |
1634 | ubifs_remount_ro(c); | 1671 | ubifs_remount_ro(c); |
1635 | 1672 | ||
1673 | if (c->bulk_read == 1) | ||
1674 | bu_init(c); | ||
1675 | else { | ||
1676 | dbg_gen("disable bulk-read"); | ||
1677 | kfree(c->bu.buf); | ||
1678 | c->bu.buf = NULL; | ||
1679 | } | ||
1680 | |||
1636 | return 0; | 1681 | return 0; |
1637 | } | 1682 | } |
1638 | 1683 | ||
@@ -1723,6 +1768,7 @@ static int ubifs_fill_super(struct super_block *sb, void *data, int silent) | |||
1723 | mutex_init(&c->log_mutex); | 1768 | mutex_init(&c->log_mutex); |
1724 | mutex_init(&c->mst_mutex); | 1769 | mutex_init(&c->mst_mutex); |
1725 | mutex_init(&c->umount_mutex); | 1770 | mutex_init(&c->umount_mutex); |
1771 | mutex_init(&c->bu_mutex); | ||
1726 | init_waitqueue_head(&c->cmt_wq); | 1772 | init_waitqueue_head(&c->cmt_wq); |
1727 | c->buds = RB_ROOT; | 1773 | c->buds = RB_ROOT; |
1728 | c->old_idx = RB_ROOT; | 1774 | c->old_idx = RB_ROOT; |
diff --git a/fs/ubifs/tnc.c b/fs/ubifs/tnc.c index d27fd918b9c..6eef5344a14 100644 --- a/fs/ubifs/tnc.c +++ b/fs/ubifs/tnc.c | |||
@@ -1501,7 +1501,12 @@ out: | |||
1501 | * @bu: bulk-read parameters and results | 1501 | * @bu: bulk-read parameters and results |
1502 | * | 1502 | * |
1503 | * Lookup consecutive data node keys for the same inode that reside | 1503 | * Lookup consecutive data node keys for the same inode that reside |
1504 | * consecutively in the same LEB. | 1504 | * consecutively in the same LEB. This function returns zero in case of success |
1505 | * and a negative error code in case of failure. | ||
1506 | * | ||
1507 | * Note, if the bulk-read buffer length (@bu->buf_len) is known, this function | ||
1508 | * makes sure bulk-read nodes fit the buffer. Otherwise, this function prepares | ||
1509 | * maxumum possible amount of nodes for bulk-read. | ||
1505 | */ | 1510 | */ |
1506 | int ubifs_tnc_get_bu_keys(struct ubifs_info *c, struct bu_info *bu) | 1511 | int ubifs_tnc_get_bu_keys(struct ubifs_info *c, struct bu_info *bu) |
1507 | { | 1512 | { |
@@ -2677,7 +2682,7 @@ int ubifs_tnc_remove_ino(struct ubifs_info *c, ino_t inum) | |||
2677 | struct ubifs_dent_node *xent, *pxent = NULL; | 2682 | struct ubifs_dent_node *xent, *pxent = NULL; |
2678 | struct qstr nm = { .name = NULL }; | 2683 | struct qstr nm = { .name = NULL }; |
2679 | 2684 | ||
2680 | dbg_tnc("ino %lu", inum); | 2685 | dbg_tnc("ino %lu", (unsigned long)inum); |
2681 | 2686 | ||
2682 | /* | 2687 | /* |
2683 | * Walk all extended attribute entries and remove them together with | 2688 | * Walk all extended attribute entries and remove them together with |
@@ -2697,7 +2702,8 @@ int ubifs_tnc_remove_ino(struct ubifs_info *c, ino_t inum) | |||
2697 | } | 2702 | } |
2698 | 2703 | ||
2699 | xattr_inum = le64_to_cpu(xent->inum); | 2704 | xattr_inum = le64_to_cpu(xent->inum); |
2700 | dbg_tnc("xent '%s', ino %lu", xent->name, xattr_inum); | 2705 | dbg_tnc("xent '%s', ino %lu", xent->name, |
2706 | (unsigned long)xattr_inum); | ||
2701 | 2707 | ||
2702 | nm.name = xent->name; | 2708 | nm.name = xent->name; |
2703 | nm.len = le16_to_cpu(xent->nlen); | 2709 | nm.len = le16_to_cpu(xent->nlen); |
diff --git a/fs/ubifs/ubifs.h b/fs/ubifs/ubifs.h index a7bd32fa15b..46b172560a0 100644 --- a/fs/ubifs/ubifs.h +++ b/fs/ubifs/ubifs.h | |||
@@ -753,7 +753,7 @@ struct ubifs_znode { | |||
753 | }; | 753 | }; |
754 | 754 | ||
755 | /** | 755 | /** |
756 | * struct bu_info - bulk-read information | 756 | * struct bu_info - bulk-read information. |
757 | * @key: first data node key | 757 | * @key: first data node key |
758 | * @zbranch: zbranches of data nodes to bulk read | 758 | * @zbranch: zbranches of data nodes to bulk read |
759 | * @buf: buffer to read into | 759 | * @buf: buffer to read into |
@@ -969,7 +969,10 @@ struct ubifs_mount_opts { | |||
969 | * @mst_node: master node | 969 | * @mst_node: master node |
970 | * @mst_offs: offset of valid master node | 970 | * @mst_offs: offset of valid master node |
971 | * @mst_mutex: protects the master node area, @mst_node, and @mst_offs | 971 | * @mst_mutex: protects the master node area, @mst_node, and @mst_offs |
972 | * @bulk_read_buf_size: buffer size for bulk-reads | 972 | * |
973 | * @max_bu_buf_len: maximum bulk-read buffer length | ||
974 | * @bu_mutex: protects the pre-allocated bulk-read buffer and @c->bu | ||
975 | * @bu: pre-allocated bulk-read information | ||
973 | * | 976 | * |
974 | * @log_lebs: number of logical eraseblocks in the log | 977 | * @log_lebs: number of logical eraseblocks in the log |
975 | * @log_bytes: log size in bytes | 978 | * @log_bytes: log size in bytes |
@@ -1217,7 +1220,10 @@ struct ubifs_info { | |||
1217 | struct ubifs_mst_node *mst_node; | 1220 | struct ubifs_mst_node *mst_node; |
1218 | int mst_offs; | 1221 | int mst_offs; |
1219 | struct mutex mst_mutex; | 1222 | struct mutex mst_mutex; |
1220 | int bulk_read_buf_size; | 1223 | |
1224 | int max_bu_buf_len; | ||
1225 | struct mutex bu_mutex; | ||
1226 | struct bu_info bu; | ||
1221 | 1227 | ||
1222 | int log_lebs; | 1228 | int log_lebs; |
1223 | long long log_bytes; | 1229 | long long log_bytes; |
diff --git a/fs/udf/inode.c b/fs/udf/inode.c index 6e74b117aaf..30ebde490f7 100644 --- a/fs/udf/inode.c +++ b/fs/udf/inode.c | |||
@@ -106,6 +106,7 @@ void udf_clear_inode(struct inode *inode) | |||
106 | udf_truncate_tail_extent(inode); | 106 | udf_truncate_tail_extent(inode); |
107 | unlock_kernel(); | 107 | unlock_kernel(); |
108 | write_inode_now(inode, 0); | 108 | write_inode_now(inode, 0); |
109 | invalidate_inode_buffers(inode); | ||
109 | } | 110 | } |
110 | iinfo = UDF_I(inode); | 111 | iinfo = UDF_I(inode); |
111 | kfree(iinfo->i_ext.i_data); | 112 | kfree(iinfo->i_ext.i_data); |