aboutsummaryrefslogtreecommitdiffstats
path: root/fs
diff options
context:
space:
mode:
Diffstat (limited to 'fs')
-rw-r--r--fs/adfs/dir_f.c2
-rw-r--r--fs/bad_inode.c330
-rw-r--r--fs/binfmt_elf.c8
-rw-r--r--fs/block_dev.c2
-rw-r--r--fs/buffer.c6
-rw-r--r--fs/gfs2/ops_fstype.c4
-rw-r--r--fs/nfs/file.c16
-rw-r--r--fs/ntfs/ChangeLog7
-rw-r--r--fs/ntfs/Makefile2
-rw-r--r--fs/ntfs/dir.c45
-rw-r--r--fs/ntfs/inode.c69
-rw-r--r--fs/ntfs/inode.h6
-rw-r--r--fs/ntfs/super.c7
-rw-r--r--fs/proc/proc_misc.c8
-rw-r--r--fs/super.c4
-rw-r--r--fs/ufs/balloc.c25
-rw-r--r--fs/ufs/inode.c41
17 files changed, 389 insertions, 193 deletions
diff --git a/fs/adfs/dir_f.c b/fs/adfs/dir_f.c
index bbfc86259272..b9b2b27b68c3 100644
--- a/fs/adfs/dir_f.c
+++ b/fs/adfs/dir_f.c
@@ -53,7 +53,7 @@ static inline int adfs_readname(char *buf, char *ptr, int maxlen)
53{ 53{
54 char *old_buf = buf; 54 char *old_buf = buf;
55 55
56 while (*ptr >= ' ' && maxlen--) { 56 while ((unsigned char)*ptr >= ' ' && maxlen--) {
57 if (*ptr == '/') 57 if (*ptr == '/')
58 *buf++ = '.'; 58 *buf++ = '.';
59 else 59 else
diff --git a/fs/bad_inode.c b/fs/bad_inode.c
index 34e6d7b220c3..869f5193ecc2 100644
--- a/fs/bad_inode.c
+++ b/fs/bad_inode.c
@@ -14,59 +14,307 @@
14#include <linux/time.h> 14#include <linux/time.h>
15#include <linux/smp_lock.h> 15#include <linux/smp_lock.h>
16#include <linux/namei.h> 16#include <linux/namei.h>
17#include <linux/poll.h>
17 18
18static int return_EIO(void) 19
20static loff_t bad_file_llseek(struct file *file, loff_t offset, int origin)
21{
22 return -EIO;
23}
24
25static ssize_t bad_file_read(struct file *filp, char __user *buf,
26 size_t size, loff_t *ppos)
27{
28 return -EIO;
29}
30
31static ssize_t bad_file_write(struct file *filp, const char __user *buf,
32 size_t siz, loff_t *ppos)
33{
34 return -EIO;
35}
36
37static ssize_t bad_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
38 unsigned long nr_segs, loff_t pos)
39{
40 return -EIO;
41}
42
43static ssize_t bad_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
44 unsigned long nr_segs, loff_t pos)
45{
46 return -EIO;
47}
48
49static int bad_file_readdir(struct file *filp, void *dirent, filldir_t filldir)
50{
51 return -EIO;
52}
53
54static unsigned int bad_file_poll(struct file *filp, poll_table *wait)
55{
56 return POLLERR;
57}
58
59static int bad_file_ioctl (struct inode *inode, struct file *filp,
60 unsigned int cmd, unsigned long arg)
61{
62 return -EIO;
63}
64
65static long bad_file_unlocked_ioctl(struct file *file, unsigned cmd,
66 unsigned long arg)
67{
68 return -EIO;
69}
70
71static long bad_file_compat_ioctl(struct file *file, unsigned int cmd,
72 unsigned long arg)
73{
74 return -EIO;
75}
76
77static int bad_file_mmap(struct file *file, struct vm_area_struct *vma)
78{
79 return -EIO;
80}
81
82static int bad_file_open(struct inode *inode, struct file *filp)
83{
84 return -EIO;
85}
86
87static int bad_file_flush(struct file *file, fl_owner_t id)
88{
89 return -EIO;
90}
91
92static int bad_file_release(struct inode *inode, struct file *filp)
93{
94 return -EIO;
95}
96
97static int bad_file_fsync(struct file *file, struct dentry *dentry,
98 int datasync)
99{
100 return -EIO;
101}
102
103static int bad_file_aio_fsync(struct kiocb *iocb, int datasync)
104{
105 return -EIO;
106}
107
108static int bad_file_fasync(int fd, struct file *filp, int on)
109{
110 return -EIO;
111}
112
113static int bad_file_lock(struct file *file, int cmd, struct file_lock *fl)
114{
115 return -EIO;
116}
117
118static ssize_t bad_file_sendfile(struct file *in_file, loff_t *ppos,
119 size_t count, read_actor_t actor, void *target)
120{
121 return -EIO;
122}
123
124static ssize_t bad_file_sendpage(struct file *file, struct page *page,
125 int off, size_t len, loff_t *pos, int more)
126{
127 return -EIO;
128}
129
130static unsigned long bad_file_get_unmapped_area(struct file *file,
131 unsigned long addr, unsigned long len,
132 unsigned long pgoff, unsigned long flags)
133{
134 return -EIO;
135}
136
137static int bad_file_check_flags(int flags)
19{ 138{
20 return -EIO; 139 return -EIO;
21} 140}
22 141
23#define EIO_ERROR ((void *) (return_EIO)) 142static int bad_file_dir_notify(struct file *file, unsigned long arg)
143{
144 return -EIO;
145}
146
147static int bad_file_flock(struct file *filp, int cmd, struct file_lock *fl)
148{
149 return -EIO;
150}
151
152static ssize_t bad_file_splice_write(struct pipe_inode_info *pipe,
153 struct file *out, loff_t *ppos, size_t len,
154 unsigned int flags)
155{
156 return -EIO;
157}
158
159static ssize_t bad_file_splice_read(struct file *in, loff_t *ppos,
160 struct pipe_inode_info *pipe, size_t len,
161 unsigned int flags)
162{
163 return -EIO;
164}
24 165
25static const struct file_operations bad_file_ops = 166static const struct file_operations bad_file_ops =
26{ 167{
27 .llseek = EIO_ERROR, 168 .llseek = bad_file_llseek,
28 .aio_read = EIO_ERROR, 169 .read = bad_file_read,
29 .read = EIO_ERROR, 170 .write = bad_file_write,
30 .write = EIO_ERROR, 171 .aio_read = bad_file_aio_read,
31 .aio_write = EIO_ERROR, 172 .aio_write = bad_file_aio_write,
32 .readdir = EIO_ERROR, 173 .readdir = bad_file_readdir,
33 .poll = EIO_ERROR, 174 .poll = bad_file_poll,
34 .ioctl = EIO_ERROR, 175 .ioctl = bad_file_ioctl,
35 .mmap = EIO_ERROR, 176 .unlocked_ioctl = bad_file_unlocked_ioctl,
36 .open = EIO_ERROR, 177 .compat_ioctl = bad_file_compat_ioctl,
37 .flush = EIO_ERROR, 178 .mmap = bad_file_mmap,
38 .release = EIO_ERROR, 179 .open = bad_file_open,
39 .fsync = EIO_ERROR, 180 .flush = bad_file_flush,
40 .aio_fsync = EIO_ERROR, 181 .release = bad_file_release,
41 .fasync = EIO_ERROR, 182 .fsync = bad_file_fsync,
42 .lock = EIO_ERROR, 183 .aio_fsync = bad_file_aio_fsync,
43 .sendfile = EIO_ERROR, 184 .fasync = bad_file_fasync,
44 .sendpage = EIO_ERROR, 185 .lock = bad_file_lock,
45 .get_unmapped_area = EIO_ERROR, 186 .sendfile = bad_file_sendfile,
187 .sendpage = bad_file_sendpage,
188 .get_unmapped_area = bad_file_get_unmapped_area,
189 .check_flags = bad_file_check_flags,
190 .dir_notify = bad_file_dir_notify,
191 .flock = bad_file_flock,
192 .splice_write = bad_file_splice_write,
193 .splice_read = bad_file_splice_read,
46}; 194};
47 195
196static int bad_inode_create (struct inode *dir, struct dentry *dentry,
197 int mode, struct nameidata *nd)
198{
199 return -EIO;
200}
201
202static struct dentry *bad_inode_lookup(struct inode *dir,
203 struct dentry *dentry, struct nameidata *nd)
204{
205 return ERR_PTR(-EIO);
206}
207
208static int bad_inode_link (struct dentry *old_dentry, struct inode *dir,
209 struct dentry *dentry)
210{
211 return -EIO;
212}
213
214static int bad_inode_unlink(struct inode *dir, struct dentry *dentry)
215{
216 return -EIO;
217}
218
219static int bad_inode_symlink (struct inode *dir, struct dentry *dentry,
220 const char *symname)
221{
222 return -EIO;
223}
224
225static int bad_inode_mkdir(struct inode *dir, struct dentry *dentry,
226 int mode)
227{
228 return -EIO;
229}
230
231static int bad_inode_rmdir (struct inode *dir, struct dentry *dentry)
232{
233 return -EIO;
234}
235
236static int bad_inode_mknod (struct inode *dir, struct dentry *dentry,
237 int mode, dev_t rdev)
238{
239 return -EIO;
240}
241
242static int bad_inode_rename (struct inode *old_dir, struct dentry *old_dentry,
243 struct inode *new_dir, struct dentry *new_dentry)
244{
245 return -EIO;
246}
247
248static int bad_inode_readlink(struct dentry *dentry, char __user *buffer,
249 int buflen)
250{
251 return -EIO;
252}
253
254static int bad_inode_permission(struct inode *inode, int mask,
255 struct nameidata *nd)
256{
257 return -EIO;
258}
259
260static int bad_inode_getattr(struct vfsmount *mnt, struct dentry *dentry,
261 struct kstat *stat)
262{
263 return -EIO;
264}
265
266static int bad_inode_setattr(struct dentry *direntry, struct iattr *attrs)
267{
268 return -EIO;
269}
270
271static int bad_inode_setxattr(struct dentry *dentry, const char *name,
272 const void *value, size_t size, int flags)
273{
274 return -EIO;
275}
276
277static ssize_t bad_inode_getxattr(struct dentry *dentry, const char *name,
278 void *buffer, size_t size)
279{
280 return -EIO;
281}
282
283static ssize_t bad_inode_listxattr(struct dentry *dentry, char *buffer,
284 size_t buffer_size)
285{
286 return -EIO;
287}
288
289static int bad_inode_removexattr(struct dentry *dentry, const char *name)
290{
291 return -EIO;
292}
293
48static struct inode_operations bad_inode_ops = 294static struct inode_operations bad_inode_ops =
49{ 295{
50 .create = EIO_ERROR, 296 .create = bad_inode_create,
51 .lookup = EIO_ERROR, 297 .lookup = bad_inode_lookup,
52 .link = EIO_ERROR, 298 .link = bad_inode_link,
53 .unlink = EIO_ERROR, 299 .unlink = bad_inode_unlink,
54 .symlink = EIO_ERROR, 300 .symlink = bad_inode_symlink,
55 .mkdir = EIO_ERROR, 301 .mkdir = bad_inode_mkdir,
56 .rmdir = EIO_ERROR, 302 .rmdir = bad_inode_rmdir,
57 .mknod = EIO_ERROR, 303 .mknod = bad_inode_mknod,
58 .rename = EIO_ERROR, 304 .rename = bad_inode_rename,
59 .readlink = EIO_ERROR, 305 .readlink = bad_inode_readlink,
60 /* follow_link must be no-op, otherwise unmounting this inode 306 /* follow_link must be no-op, otherwise unmounting this inode
61 won't work */ 307 won't work */
62 .truncate = EIO_ERROR, 308 /* put_link returns void */
63 .permission = EIO_ERROR, 309 /* truncate returns void */
64 .getattr = EIO_ERROR, 310 .permission = bad_inode_permission,
65 .setattr = EIO_ERROR, 311 .getattr = bad_inode_getattr,
66 .setxattr = EIO_ERROR, 312 .setattr = bad_inode_setattr,
67 .getxattr = EIO_ERROR, 313 .setxattr = bad_inode_setxattr,
68 .listxattr = EIO_ERROR, 314 .getxattr = bad_inode_getxattr,
69 .removexattr = EIO_ERROR, 315 .listxattr = bad_inode_listxattr,
316 .removexattr = bad_inode_removexattr,
317 /* truncate_range returns void */
70}; 318};
71 319
72 320
@@ -88,7 +336,7 @@ static struct inode_operations bad_inode_ops =
88 * on it to fail from this point on. 336 * on it to fail from this point on.
89 */ 337 */
90 338
91void make_bad_inode(struct inode * inode) 339void make_bad_inode(struct inode *inode)
92{ 340{
93 remove_inode_hash(inode); 341 remove_inode_hash(inode);
94 342
@@ -113,7 +361,7 @@ EXPORT_SYMBOL(make_bad_inode);
113 * Returns true if the inode in question has been marked as bad. 361 * Returns true if the inode in question has been marked as bad.
114 */ 362 */
115 363
116int is_bad_inode(struct inode * inode) 364int is_bad_inode(struct inode *inode)
117{ 365{
118 return (inode->i_op == &bad_inode_ops); 366 return (inode->i_op == &bad_inode_ops);
119} 367}
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index d3adfd353ff9..7cb28720f90e 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -854,13 +854,7 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
854 * default mmap base, as well as whatever program they 854 * default mmap base, as well as whatever program they
855 * might try to exec. This is because the brk will 855 * might try to exec. This is because the brk will
856 * follow the loader, and is not movable. */ 856 * follow the loader, and is not movable. */
857 if (current->flags & PF_RANDOMIZE) 857 load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
858 load_bias = randomize_range(0x10000,
859 ELF_ET_DYN_BASE,
860 0);
861 else
862 load_bias = ELF_ET_DYN_BASE;
863 load_bias = ELF_PAGESTART(load_bias - vaddr);
864 } 858 }
865 859
866 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt, 860 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 1715d6b5f411..8b18e43b82fe 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -411,7 +411,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
411 { 411 {
412 memset(bdev, 0, sizeof(*bdev)); 412 memset(bdev, 0, sizeof(*bdev));
413 mutex_init(&bdev->bd_mutex); 413 mutex_init(&bdev->bd_mutex);
414 mutex_init(&bdev->bd_mount_mutex); 414 sema_init(&bdev->bd_mount_sem, 1);
415 INIT_LIST_HEAD(&bdev->bd_inodes); 415 INIT_LIST_HEAD(&bdev->bd_inodes);
416 INIT_LIST_HEAD(&bdev->bd_list); 416 INIT_LIST_HEAD(&bdev->bd_list);
417#ifdef CONFIG_SYSFS 417#ifdef CONFIG_SYSFS
diff --git a/fs/buffer.c b/fs/buffer.c
index 263f88e4dffb..3b116078b4c3 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -180,7 +180,7 @@ int fsync_bdev(struct block_device *bdev)
180 * freeze_bdev -- lock a filesystem and force it into a consistent state 180 * freeze_bdev -- lock a filesystem and force it into a consistent state
181 * @bdev: blockdevice to lock 181 * @bdev: blockdevice to lock
182 * 182 *
183 * This takes the block device bd_mount_mutex to make sure no new mounts 183 * This takes the block device bd_mount_sem to make sure no new mounts
184 * happen on bdev until thaw_bdev() is called. 184 * happen on bdev until thaw_bdev() is called.
185 * If a superblock is found on this device, we take the s_umount semaphore 185 * If a superblock is found on this device, we take the s_umount semaphore
186 * on it to make sure nobody unmounts until the snapshot creation is done. 186 * on it to make sure nobody unmounts until the snapshot creation is done.
@@ -189,7 +189,7 @@ struct super_block *freeze_bdev(struct block_device *bdev)
189{ 189{
190 struct super_block *sb; 190 struct super_block *sb;
191 191
192 mutex_lock(&bdev->bd_mount_mutex); 192 down(&bdev->bd_mount_sem);
193 sb = get_super(bdev); 193 sb = get_super(bdev);
194 if (sb && !(sb->s_flags & MS_RDONLY)) { 194 if (sb && !(sb->s_flags & MS_RDONLY)) {
195 sb->s_frozen = SB_FREEZE_WRITE; 195 sb->s_frozen = SB_FREEZE_WRITE;
@@ -231,7 +231,7 @@ void thaw_bdev(struct block_device *bdev, struct super_block *sb)
231 drop_super(sb); 231 drop_super(sb);
232 } 232 }
233 233
234 mutex_unlock(&bdev->bd_mount_mutex); 234 up(&bdev->bd_mount_sem);
235} 235}
236EXPORT_SYMBOL(thaw_bdev); 236EXPORT_SYMBOL(thaw_bdev);
237 237
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index d14e139d2674..ee80b8a5e7bc 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -867,9 +867,9 @@ static int gfs2_get_sb_meta(struct file_system_type *fs_type, int flags,
867 error = -EBUSY; 867 error = -EBUSY;
868 goto error; 868 goto error;
869 } 869 }
870 mutex_lock(&sb->s_bdev->bd_mount_mutex); 870 down(&sb->s_bdev->bd_mount_sem);
871 new = sget(fs_type, test_bdev_super, set_bdev_super, sb->s_bdev); 871 new = sget(fs_type, test_bdev_super, set_bdev_super, sb->s_bdev);
872 mutex_unlock(&sb->s_bdev->bd_mount_mutex); 872 up(&sb->s_bdev->bd_mount_sem);
873 if (IS_ERR(new)) { 873 if (IS_ERR(new)) {
874 error = PTR_ERR(new); 874 error = PTR_ERR(new);
875 goto error; 875 goto error;
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 0dd6be346aa7..fab20d06d936 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -315,14 +315,13 @@ static void nfs_invalidate_page(struct page *page, unsigned long offset)
315 315
316static int nfs_release_page(struct page *page, gfp_t gfp) 316static int nfs_release_page(struct page *page, gfp_t gfp)
317{ 317{
318 /* 318 /* If PagePrivate() is set, then the page is not freeable */
319 * Avoid deadlock on nfs_wait_on_request(). 319 return 0;
320 */ 320}
321 if (!(gfp & __GFP_FS)) 321
322 return 0; 322static int nfs_launder_page(struct page *page)
323 /* Hack... Force nfs_wb_page() to write out the page */ 323{
324 SetPageDirty(page); 324 return nfs_wb_page(page->mapping->host, page);
325 return !nfs_wb_page(page->mapping->host, page);
326} 325}
327 326
328const struct address_space_operations nfs_file_aops = { 327const struct address_space_operations nfs_file_aops = {
@@ -338,6 +337,7 @@ const struct address_space_operations nfs_file_aops = {
338#ifdef CONFIG_NFS_DIRECTIO 337#ifdef CONFIG_NFS_DIRECTIO
339 .direct_IO = nfs_direct_IO, 338 .direct_IO = nfs_direct_IO,
340#endif 339#endif
340 .launder_page = nfs_launder_page,
341}; 341};
342 342
343static ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov, 343static ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov,
diff --git a/fs/ntfs/ChangeLog b/fs/ntfs/ChangeLog
index 35cc4b1d60f7..af4ef808fa94 100644
--- a/fs/ntfs/ChangeLog
+++ b/fs/ntfs/ChangeLog
@@ -17,6 +17,13 @@ ToDo/Notes:
17 happen is unclear however so it is worth waiting until someone hits 17 happen is unclear however so it is worth waiting until someone hits
18 the problem. 18 the problem.
19 19
202.1.28 - Fix a deadlock.
21
22 - Fix deadlock in fs/ntfs/inode.c::ntfs_put_inode(). Thanks to Sergey
23 Vlasov for the report and detailed analysis of the deadlock. The fix
24 involved getting rid of ntfs_put_inode() altogether and hence NTFS no
25 longer has a ->put_inode super operation.
26
202.1.27 - Various bug fixes and cleanups. 272.1.27 - Various bug fixes and cleanups.
21 28
22 - Fix two compiler warnings on Alpha. Thanks to Andrew Morton for 29 - Fix two compiler warnings on Alpha. Thanks to Andrew Morton for
diff --git a/fs/ntfs/Makefile b/fs/ntfs/Makefile
index e27b4eacffbf..825508385565 100644
--- a/fs/ntfs/Makefile
+++ b/fs/ntfs/Makefile
@@ -6,7 +6,7 @@ ntfs-objs := aops.o attrib.o collate.o compress.o debug.o dir.o file.o \
6 index.o inode.o mft.o mst.o namei.o runlist.o super.o sysctl.o \ 6 index.o inode.o mft.o mst.o namei.o runlist.o super.o sysctl.o \
7 unistr.o upcase.o 7 unistr.o upcase.o
8 8
9EXTRA_CFLAGS = -DNTFS_VERSION=\"2.1.27\" 9EXTRA_CFLAGS = -DNTFS_VERSION=\"2.1.28\"
10 10
11ifeq ($(CONFIG_NTFS_DEBUG),y) 11ifeq ($(CONFIG_NTFS_DEBUG),y)
12EXTRA_CFLAGS += -DDEBUG 12EXTRA_CFLAGS += -DDEBUG
diff --git a/fs/ntfs/dir.c b/fs/ntfs/dir.c
index 8296c29ae3b8..74f99a6a369b 100644
--- a/fs/ntfs/dir.c
+++ b/fs/ntfs/dir.c
@@ -1,7 +1,7 @@
1/** 1/**
2 * dir.c - NTFS kernel directory operations. Part of the Linux-NTFS project. 2 * dir.c - NTFS kernel directory operations. Part of the Linux-NTFS project.
3 * 3 *
4 * Copyright (c) 2001-2005 Anton Altaparmakov 4 * Copyright (c) 2001-2007 Anton Altaparmakov
5 * Copyright (c) 2002 Richard Russon 5 * Copyright (c) 2002 Richard Russon
6 * 6 *
7 * This program/include file is free software; you can redistribute it and/or 7 * This program/include file is free software; you can redistribute it and/or
@@ -1249,16 +1249,12 @@ skip_index_root:
1249 /* Get the offset into the index allocation attribute. */ 1249 /* Get the offset into the index allocation attribute. */
1250 ia_pos = (s64)fpos - vol->mft_record_size; 1250 ia_pos = (s64)fpos - vol->mft_record_size;
1251 ia_mapping = vdir->i_mapping; 1251 ia_mapping = vdir->i_mapping;
1252 bmp_vi = ndir->itype.index.bmp_ino; 1252 ntfs_debug("Inode 0x%lx, getting index bitmap.", vdir->i_ino);
1253 if (unlikely(!bmp_vi)) { 1253 bmp_vi = ntfs_attr_iget(vdir, AT_BITMAP, I30, 4);
1254 ntfs_debug("Inode 0x%lx, regetting index bitmap.", vdir->i_ino); 1254 if (IS_ERR(bmp_vi)) {
1255 bmp_vi = ntfs_attr_iget(vdir, AT_BITMAP, I30, 4); 1255 ntfs_error(sb, "Failed to get bitmap attribute.");
1256 if (IS_ERR(bmp_vi)) { 1256 err = PTR_ERR(bmp_vi);
1257 ntfs_error(sb, "Failed to get bitmap attribute."); 1257 goto err_out;
1258 err = PTR_ERR(bmp_vi);
1259 goto err_out;
1260 }
1261 ndir->itype.index.bmp_ino = bmp_vi;
1262 } 1258 }
1263 bmp_mapping = bmp_vi->i_mapping; 1259 bmp_mapping = bmp_vi->i_mapping;
1264 /* Get the starting bitmap bit position and sanity check it. */ 1260 /* Get the starting bitmap bit position and sanity check it. */
@@ -1266,7 +1262,7 @@ skip_index_root:
1266 if (unlikely(bmp_pos >> 3 >= i_size_read(bmp_vi))) { 1262 if (unlikely(bmp_pos >> 3 >= i_size_read(bmp_vi))) {
1267 ntfs_error(sb, "Current index allocation position exceeds " 1263 ntfs_error(sb, "Current index allocation position exceeds "
1268 "index bitmap size."); 1264 "index bitmap size.");
1269 goto err_out; 1265 goto iput_err_out;
1270 } 1266 }
1271 /* Get the starting bit position in the current bitmap page. */ 1267 /* Get the starting bit position in the current bitmap page. */
1272 cur_bmp_pos = bmp_pos & ((PAGE_CACHE_SIZE * 8) - 1); 1268 cur_bmp_pos = bmp_pos & ((PAGE_CACHE_SIZE * 8) - 1);
@@ -1282,7 +1278,7 @@ get_next_bmp_page:
1282 ntfs_error(sb, "Reading index bitmap failed."); 1278 ntfs_error(sb, "Reading index bitmap failed.");
1283 err = PTR_ERR(bmp_page); 1279 err = PTR_ERR(bmp_page);
1284 bmp_page = NULL; 1280 bmp_page = NULL;
1285 goto err_out; 1281 goto iput_err_out;
1286 } 1282 }
1287 bmp = (u8*)page_address(bmp_page); 1283 bmp = (u8*)page_address(bmp_page);
1288 /* Find next index block in use. */ 1284 /* Find next index block in use. */
@@ -1429,6 +1425,7 @@ find_next_index_buffer:
1429 /* @ia_page is already unlocked in this case. */ 1425 /* @ia_page is already unlocked in this case. */
1430 ntfs_unmap_page(ia_page); 1426 ntfs_unmap_page(ia_page);
1431 ntfs_unmap_page(bmp_page); 1427 ntfs_unmap_page(bmp_page);
1428 iput(bmp_vi);
1432 goto abort; 1429 goto abort;
1433 } 1430 }
1434 } 1431 }
@@ -1439,6 +1436,7 @@ unm_EOD:
1439 ntfs_unmap_page(ia_page); 1436 ntfs_unmap_page(ia_page);
1440 } 1437 }
1441 ntfs_unmap_page(bmp_page); 1438 ntfs_unmap_page(bmp_page);
1439 iput(bmp_vi);
1442EOD: 1440EOD:
1443 /* We are finished, set fpos to EOD. */ 1441 /* We are finished, set fpos to EOD. */
1444 fpos = i_size + vol->mft_record_size; 1442 fpos = i_size + vol->mft_record_size;
@@ -1455,8 +1453,11 @@ done:
1455 filp->f_pos = fpos; 1453 filp->f_pos = fpos;
1456 return 0; 1454 return 0;
1457err_out: 1455err_out:
1458 if (bmp_page) 1456 if (bmp_page) {
1459 ntfs_unmap_page(bmp_page); 1457 ntfs_unmap_page(bmp_page);
1458iput_err_out:
1459 iput(bmp_vi);
1460 }
1460 if (ia_page) { 1461 if (ia_page) {
1461 unlock_page(ia_page); 1462 unlock_page(ia_page);
1462 ntfs_unmap_page(ia_page); 1463 ntfs_unmap_page(ia_page);
@@ -1529,14 +1530,22 @@ static int ntfs_dir_open(struct inode *vi, struct file *filp)
1529static int ntfs_dir_fsync(struct file *filp, struct dentry *dentry, 1530static int ntfs_dir_fsync(struct file *filp, struct dentry *dentry,
1530 int datasync) 1531 int datasync)
1531{ 1532{
1532 struct inode *vi = dentry->d_inode; 1533 struct inode *bmp_vi, *vi = dentry->d_inode;
1533 ntfs_inode *ni = NTFS_I(vi);
1534 int err, ret; 1534 int err, ret;
1535 ntfs_attr na;
1535 1536
1536 ntfs_debug("Entering for inode 0x%lx.", vi->i_ino); 1537 ntfs_debug("Entering for inode 0x%lx.", vi->i_ino);
1537 BUG_ON(!S_ISDIR(vi->i_mode)); 1538 BUG_ON(!S_ISDIR(vi->i_mode));
1538 if (NInoIndexAllocPresent(ni) && ni->itype.index.bmp_ino) 1539 /* If the bitmap attribute inode is in memory sync it, too. */
1539 write_inode_now(ni->itype.index.bmp_ino, !datasync); 1540 na.mft_no = vi->i_ino;
1541 na.type = AT_BITMAP;
1542 na.name = I30;
1543 na.name_len = 4;
1544 bmp_vi = ilookup5(vi->i_sb, vi->i_ino, (test_t)ntfs_test_inode, &na);
1545 if (bmp_vi) {
1546 write_inode_now(bmp_vi, !datasync);
1547 iput(bmp_vi);
1548 }
1540 ret = ntfs_write_inode(vi, 1); 1549 ret = ntfs_write_inode(vi, 1);
1541 write_inode_now(vi, !datasync); 1550 write_inode_now(vi, !datasync);
1542 err = sync_blockdev(vi->i_sb->s_bdev); 1551 err = sync_blockdev(vi->i_sb->s_bdev);
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index 247989891b4b..f8bf8da67ee8 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -1,7 +1,7 @@
1/** 1/**
2 * inode.c - NTFS kernel inode handling. Part of the Linux-NTFS project. 2 * inode.c - NTFS kernel inode handling. Part of the Linux-NTFS project.
3 * 3 *
4 * Copyright (c) 2001-2006 Anton Altaparmakov 4 * Copyright (c) 2001-2007 Anton Altaparmakov
5 * 5 *
6 * This program/include file is free software; you can redistribute it and/or 6 * This program/include file is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as published 7 * modify it under the terms of the GNU General Public License as published
@@ -95,7 +95,7 @@ int ntfs_test_inode(struct inode *vi, ntfs_attr *na)
95 * If initializing the normal file/directory inode, set @na->type to AT_UNUSED. 95 * If initializing the normal file/directory inode, set @na->type to AT_UNUSED.
96 * In that case, @na->name and @na->name_len should be set to NULL and 0, 96 * In that case, @na->name and @na->name_len should be set to NULL and 0,
97 * respectively. Although that is not strictly necessary as 97 * respectively. Although that is not strictly necessary as
98 * ntfs_read_inode_locked() will fill them in later. 98 * ntfs_read_locked_inode() will fill them in later.
99 * 99 *
100 * Return 0 on success and -errno on error. 100 * Return 0 on success and -errno on error.
101 * 101 *
@@ -171,8 +171,8 @@ static int ntfs_read_locked_index_inode(struct inode *base_vi,
171struct inode *ntfs_iget(struct super_block *sb, unsigned long mft_no) 171struct inode *ntfs_iget(struct super_block *sb, unsigned long mft_no)
172{ 172{
173 struct inode *vi; 173 struct inode *vi;
174 ntfs_attr na;
175 int err; 174 int err;
175 ntfs_attr na;
176 176
177 na.mft_no = mft_no; 177 na.mft_no = mft_no;
178 na.type = AT_UNUSED; 178 na.type = AT_UNUSED;
@@ -229,8 +229,8 @@ struct inode *ntfs_attr_iget(struct inode *base_vi, ATTR_TYPE type,
229 ntfschar *name, u32 name_len) 229 ntfschar *name, u32 name_len)
230{ 230{
231 struct inode *vi; 231 struct inode *vi;
232 ntfs_attr na;
233 int err; 232 int err;
233 ntfs_attr na;
234 234
235 /* Make sure no one calls ntfs_attr_iget() for indices. */ 235 /* Make sure no one calls ntfs_attr_iget() for indices. */
236 BUG_ON(type == AT_INDEX_ALLOCATION); 236 BUG_ON(type == AT_INDEX_ALLOCATION);
@@ -287,8 +287,8 @@ struct inode *ntfs_index_iget(struct inode *base_vi, ntfschar *name,
287 u32 name_len) 287 u32 name_len)
288{ 288{
289 struct inode *vi; 289 struct inode *vi;
290 ntfs_attr na;
291 int err; 290 int err;
291 ntfs_attr na;
292 292
293 na.mft_no = base_vi->i_ino; 293 na.mft_no = base_vi->i_ino;
294 na.type = AT_INDEX_ALLOCATION; 294 na.type = AT_INDEX_ALLOCATION;
@@ -402,7 +402,6 @@ void __ntfs_init_inode(struct super_block *sb, ntfs_inode *ni)
402 ntfs_init_runlist(&ni->attr_list_rl); 402 ntfs_init_runlist(&ni->attr_list_rl);
403 lockdep_set_class(&ni->attr_list_rl.lock, 403 lockdep_set_class(&ni->attr_list_rl.lock,
404 &attr_list_rl_lock_class); 404 &attr_list_rl_lock_class);
405 ni->itype.index.bmp_ino = NULL;
406 ni->itype.index.block_size = 0; 405 ni->itype.index.block_size = 0;
407 ni->itype.index.vcn_size = 0; 406 ni->itype.index.vcn_size = 0;
408 ni->itype.index.collation_rule = 0; 407 ni->itype.index.collation_rule = 0;
@@ -546,6 +545,7 @@ static int ntfs_read_locked_inode(struct inode *vi)
546{ 545{
547 ntfs_volume *vol = NTFS_SB(vi->i_sb); 546 ntfs_volume *vol = NTFS_SB(vi->i_sb);
548 ntfs_inode *ni; 547 ntfs_inode *ni;
548 struct inode *bvi;
549 MFT_RECORD *m; 549 MFT_RECORD *m;
550 ATTR_RECORD *a; 550 ATTR_RECORD *a;
551 STANDARD_INFORMATION *si; 551 STANDARD_INFORMATION *si;
@@ -780,7 +780,6 @@ skip_attr_list_load:
780 */ 780 */
781 if (S_ISDIR(vi->i_mode)) { 781 if (S_ISDIR(vi->i_mode)) {
782 loff_t bvi_size; 782 loff_t bvi_size;
783 struct inode *bvi;
784 ntfs_inode *bni; 783 ntfs_inode *bni;
785 INDEX_ROOT *ir; 784 INDEX_ROOT *ir;
786 u8 *ir_end, *index_end; 785 u8 *ir_end, *index_end;
@@ -985,13 +984,12 @@ skip_attr_list_load:
985 err = PTR_ERR(bvi); 984 err = PTR_ERR(bvi);
986 goto unm_err_out; 985 goto unm_err_out;
987 } 986 }
988 ni->itype.index.bmp_ino = bvi;
989 bni = NTFS_I(bvi); 987 bni = NTFS_I(bvi);
990 if (NInoCompressed(bni) || NInoEncrypted(bni) || 988 if (NInoCompressed(bni) || NInoEncrypted(bni) ||
991 NInoSparse(bni)) { 989 NInoSparse(bni)) {
992 ntfs_error(vi->i_sb, "$BITMAP attribute is compressed " 990 ntfs_error(vi->i_sb, "$BITMAP attribute is compressed "
993 "and/or encrypted and/or sparse."); 991 "and/or encrypted and/or sparse.");
994 goto unm_err_out; 992 goto iput_unm_err_out;
995 } 993 }
996 /* Consistency check bitmap size vs. index allocation size. */ 994 /* Consistency check bitmap size vs. index allocation size. */
997 bvi_size = i_size_read(bvi); 995 bvi_size = i_size_read(bvi);
@@ -1000,8 +998,10 @@ skip_attr_list_load:
1000 ntfs_error(vi->i_sb, "Index bitmap too small (0x%llx) " 998 ntfs_error(vi->i_sb, "Index bitmap too small (0x%llx) "
1001 "for index allocation (0x%llx).", 999 "for index allocation (0x%llx).",
1002 bvi_size << 3, vi->i_size); 1000 bvi_size << 3, vi->i_size);
1003 goto unm_err_out; 1001 goto iput_unm_err_out;
1004 } 1002 }
1003 /* No longer need the bitmap attribute inode. */
1004 iput(bvi);
1005skip_large_dir_stuff: 1005skip_large_dir_stuff:
1006 /* Setup the operations for this inode. */ 1006 /* Setup the operations for this inode. */
1007 vi->i_op = &ntfs_dir_inode_ops; 1007 vi->i_op = &ntfs_dir_inode_ops;
@@ -1176,7 +1176,8 @@ no_data_attr_special_case:
1176 vi->i_blocks = ni->allocated_size >> 9; 1176 vi->i_blocks = ni->allocated_size >> 9;
1177 ntfs_debug("Done."); 1177 ntfs_debug("Done.");
1178 return 0; 1178 return 0;
1179 1179iput_unm_err_out:
1180 iput(bvi);
1180unm_err_out: 1181unm_err_out:
1181 if (!err) 1182 if (!err)
1182 err = -EIO; 1183 err = -EIO;
@@ -1697,7 +1698,7 @@ static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi)
1697 vi->i_size); 1698 vi->i_size);
1698 goto iput_unm_err_out; 1699 goto iput_unm_err_out;
1699 } 1700 }
1700 ni->itype.index.bmp_ino = bvi; 1701 iput(bvi);
1701skip_large_index_stuff: 1702skip_large_index_stuff:
1702 /* Setup the operations for this index inode. */ 1703 /* Setup the operations for this index inode. */
1703 vi->i_op = NULL; 1704 vi->i_op = NULL;
@@ -1714,7 +1715,6 @@ skip_large_index_stuff:
1714 1715
1715 ntfs_debug("Done."); 1716 ntfs_debug("Done.");
1716 return 0; 1717 return 0;
1717
1718iput_unm_err_out: 1718iput_unm_err_out:
1719 iput(bvi); 1719 iput(bvi);
1720unm_err_out: 1720unm_err_out:
@@ -2191,37 +2191,6 @@ err_out:
2191 return -1; 2191 return -1;
2192} 2192}
2193 2193
2194/**
2195 * ntfs_put_inode - handler for when the inode reference count is decremented
2196 * @vi: vfs inode
2197 *
2198 * The VFS calls ntfs_put_inode() every time the inode reference count (i_count)
2199 * is about to be decremented (but before the decrement itself.
2200 *
2201 * If the inode @vi is a directory with two references, one of which is being
2202 * dropped, we need to put the attribute inode for the directory index bitmap,
2203 * if it is present, otherwise the directory inode would remain pinned for
2204 * ever.
2205 */
2206void ntfs_put_inode(struct inode *vi)
2207{
2208 if (S_ISDIR(vi->i_mode) && atomic_read(&vi->i_count) == 2) {
2209 ntfs_inode *ni = NTFS_I(vi);
2210 if (NInoIndexAllocPresent(ni)) {
2211 struct inode *bvi = NULL;
2212 mutex_lock(&vi->i_mutex);
2213 if (atomic_read(&vi->i_count) == 2) {
2214 bvi = ni->itype.index.bmp_ino;
2215 if (bvi)
2216 ni->itype.index.bmp_ino = NULL;
2217 }
2218 mutex_unlock(&vi->i_mutex);
2219 if (bvi)
2220 iput(bvi);
2221 }
2222 }
2223}
2224
2225static void __ntfs_clear_inode(ntfs_inode *ni) 2194static void __ntfs_clear_inode(ntfs_inode *ni)
2226{ 2195{
2227 /* Free all alocated memory. */ 2196 /* Free all alocated memory. */
@@ -2287,18 +2256,6 @@ void ntfs_clear_big_inode(struct inode *vi)
2287{ 2256{
2288 ntfs_inode *ni = NTFS_I(vi); 2257 ntfs_inode *ni = NTFS_I(vi);
2289 2258
2290 /*
2291 * If the inode @vi is an index inode we need to put the attribute
2292 * inode for the index bitmap, if it is present, otherwise the index
2293 * inode would disappear and the attribute inode for the index bitmap
2294 * would no longer be referenced from anywhere and thus it would remain
2295 * pinned for ever.
2296 */
2297 if (NInoAttr(ni) && (ni->type == AT_INDEX_ALLOCATION) &&
2298 NInoIndexAllocPresent(ni) && ni->itype.index.bmp_ino) {
2299 iput(ni->itype.index.bmp_ino);
2300 ni->itype.index.bmp_ino = NULL;
2301 }
2302#ifdef NTFS_RW 2259#ifdef NTFS_RW
2303 if (NInoDirty(ni)) { 2260 if (NInoDirty(ni)) {
2304 bool was_bad = (is_bad_inode(vi)); 2261 bool was_bad = (is_bad_inode(vi));
diff --git a/fs/ntfs/inode.h b/fs/ntfs/inode.h
index f088291e017c..117eaf8032a3 100644
--- a/fs/ntfs/inode.h
+++ b/fs/ntfs/inode.h
@@ -2,7 +2,7 @@
2 * inode.h - Defines for inode structures NTFS Linux kernel driver. Part of 2 * inode.h - Defines for inode structures NTFS Linux kernel driver. Part of
3 * the Linux-NTFS project. 3 * the Linux-NTFS project.
4 * 4 *
5 * Copyright (c) 2001-2005 Anton Altaparmakov 5 * Copyright (c) 2001-2007 Anton Altaparmakov
6 * Copyright (c) 2002 Richard Russon 6 * Copyright (c) 2002 Richard Russon
7 * 7 *
8 * This program/include file is free software; you can redistribute it and/or 8 * This program/include file is free software; you can redistribute it and/or
@@ -101,8 +101,6 @@ struct _ntfs_inode {
101 runlist attr_list_rl; /* Run list for the attribute list value. */ 101 runlist attr_list_rl; /* Run list for the attribute list value. */
102 union { 102 union {
103 struct { /* It is a directory, $MFT, or an index inode. */ 103 struct { /* It is a directory, $MFT, or an index inode. */
104 struct inode *bmp_ino; /* Attribute inode for the
105 index $BITMAP. */
106 u32 block_size; /* Size of an index block. */ 104 u32 block_size; /* Size of an index block. */
107 u32 vcn_size; /* Size of a vcn in this 105 u32 vcn_size; /* Size of a vcn in this
108 index. */ 106 index. */
@@ -300,8 +298,6 @@ extern void ntfs_clear_extent_inode(ntfs_inode *ni);
300 298
301extern int ntfs_read_inode_mount(struct inode *vi); 299extern int ntfs_read_inode_mount(struct inode *vi);
302 300
303extern void ntfs_put_inode(struct inode *vi);
304
305extern int ntfs_show_options(struct seq_file *sf, struct vfsmount *mnt); 301extern int ntfs_show_options(struct seq_file *sf, struct vfsmount *mnt);
306 302
307#ifdef NTFS_RW 303#ifdef NTFS_RW
diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index 03a391ac7145..babf94d90def 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -1,7 +1,7 @@
1/* 1/*
2 * super.c - NTFS kernel super block handling. Part of the Linux-NTFS project. 2 * super.c - NTFS kernel super block handling. Part of the Linux-NTFS project.
3 * 3 *
4 * Copyright (c) 2001-2006 Anton Altaparmakov 4 * Copyright (c) 2001-2007 Anton Altaparmakov
5 * Copyright (c) 2001,2002 Richard Russon 5 * Copyright (c) 2001,2002 Richard Russon
6 * 6 *
7 * This program/include file is free software; you can redistribute it and/or 7 * This program/include file is free software; you can redistribute it and/or
@@ -2702,9 +2702,6 @@ static int ntfs_statfs(struct dentry *dentry, struct kstatfs *sfs)
2702static struct super_operations ntfs_sops = { 2702static struct super_operations ntfs_sops = {
2703 .alloc_inode = ntfs_alloc_big_inode, /* VFS: Allocate new inode. */ 2703 .alloc_inode = ntfs_alloc_big_inode, /* VFS: Allocate new inode. */
2704 .destroy_inode = ntfs_destroy_big_inode, /* VFS: Deallocate inode. */ 2704 .destroy_inode = ntfs_destroy_big_inode, /* VFS: Deallocate inode. */
2705 .put_inode = ntfs_put_inode, /* VFS: Called just before
2706 the inode reference count
2707 is decreased. */
2708#ifdef NTFS_RW 2705#ifdef NTFS_RW
2709 //.dirty_inode = NULL, /* VFS: Called from 2706 //.dirty_inode = NULL, /* VFS: Called from
2710 // __mark_inode_dirty(). */ 2707 // __mark_inode_dirty(). */
@@ -3261,7 +3258,7 @@ static void __exit exit_ntfs_fs(void)
3261} 3258}
3262 3259
3263MODULE_AUTHOR("Anton Altaparmakov <aia21@cantab.net>"); 3260MODULE_AUTHOR("Anton Altaparmakov <aia21@cantab.net>");
3264MODULE_DESCRIPTION("NTFS 1.2/3.x driver - Copyright (c) 2001-2006 Anton Altaparmakov"); 3261MODULE_DESCRIPTION("NTFS 1.2/3.x driver - Copyright (c) 2001-2007 Anton Altaparmakov");
3265MODULE_VERSION(NTFS_VERSION); 3262MODULE_VERSION(NTFS_VERSION);
3266MODULE_LICENSE("GPL"); 3263MODULE_LICENSE("GPL");
3267#ifdef DEBUG 3264#ifdef DEBUG
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 92ea7743fe8f..b37ce33f67ea 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -47,7 +47,6 @@
47#include <linux/vmalloc.h> 47#include <linux/vmalloc.h>
48#include <linux/crash_dump.h> 48#include <linux/crash_dump.h>
49#include <linux/pid_namespace.h> 49#include <linux/pid_namespace.h>
50#include <linux/compile.h>
51#include <asm/uaccess.h> 50#include <asm/uaccess.h>
52#include <asm/pgtable.h> 51#include <asm/pgtable.h>
53#include <asm/io.h> 52#include <asm/io.h>
@@ -254,12 +253,7 @@ static int version_read_proc(char *page, char **start, off_t off,
254{ 253{
255 int len; 254 int len;
256 255
257 /* FIXED STRING! Don't touch! */ 256 len = snprintf(page, PAGE_SIZE, linux_proc_banner,
258 len = snprintf(page, PAGE_SIZE,
259 "%s version %s"
260 " (" LINUX_COMPILE_BY "@" LINUX_COMPILE_HOST ")"
261 " (" LINUX_COMPILER ")"
262 " %s\n",
263 utsname()->sysname, 257 utsname()->sysname,
264 utsname()->release, 258 utsname()->release,
265 utsname()->version); 259 utsname()->version);
diff --git a/fs/super.c b/fs/super.c
index f961e0307997..3e7458c2bb76 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -753,9 +753,9 @@ int get_sb_bdev(struct file_system_type *fs_type,
753 * will protect the lockfs code from trying to start a snapshot 753 * will protect the lockfs code from trying to start a snapshot
754 * while we are mounting 754 * while we are mounting
755 */ 755 */
756 mutex_lock(&bdev->bd_mount_mutex); 756 down(&bdev->bd_mount_sem);
757 s = sget(fs_type, test_bdev_super, set_bdev_super, bdev); 757 s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
758 mutex_unlock(&bdev->bd_mount_mutex); 758 up(&bdev->bd_mount_sem);
759 if (IS_ERR(s)) 759 if (IS_ERR(s))
760 goto error_s; 760 goto error_s;
761 761
diff --git a/fs/ufs/balloc.c b/fs/ufs/balloc.c
index b82381475779..2e0021e8f366 100644
--- a/fs/ufs/balloc.c
+++ b/fs/ufs/balloc.c
@@ -275,6 +275,25 @@ static void ufs_change_blocknr(struct inode *inode, unsigned int baseblk,
275 UFSD("EXIT\n"); 275 UFSD("EXIT\n");
276} 276}
277 277
278static void ufs_clear_frags(struct inode *inode, sector_t beg, unsigned int n,
279 int sync)
280{
281 struct buffer_head *bh;
282 sector_t end = beg + n;
283
284 for (; beg < end; ++beg) {
285 bh = sb_getblk(inode->i_sb, beg);
286 lock_buffer(bh);
287 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
288 set_buffer_uptodate(bh);
289 mark_buffer_dirty(bh);
290 unlock_buffer(bh);
291 if (IS_SYNC(inode) || sync)
292 sync_dirty_buffer(bh);
293 brelse(bh);
294 }
295}
296
278unsigned ufs_new_fragments(struct inode * inode, __fs32 * p, unsigned fragment, 297unsigned ufs_new_fragments(struct inode * inode, __fs32 * p, unsigned fragment,
279 unsigned goal, unsigned count, int * err, struct page *locked_page) 298 unsigned goal, unsigned count, int * err, struct page *locked_page)
280{ 299{
@@ -350,6 +369,8 @@ unsigned ufs_new_fragments(struct inode * inode, __fs32 * p, unsigned fragment,
350 *p = cpu_to_fs32(sb, result); 369 *p = cpu_to_fs32(sb, result);
351 *err = 0; 370 *err = 0;
352 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count); 371 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
372 ufs_clear_frags(inode, result + oldcount, newcount - oldcount,
373 locked_page != NULL);
353 } 374 }
354 unlock_super(sb); 375 unlock_super(sb);
355 UFSD("EXIT, result %u\n", result); 376 UFSD("EXIT, result %u\n", result);
@@ -363,6 +384,8 @@ unsigned ufs_new_fragments(struct inode * inode, __fs32 * p, unsigned fragment,
363 if (result) { 384 if (result) {
364 *err = 0; 385 *err = 0;
365 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count); 386 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
387 ufs_clear_frags(inode, result + oldcount, newcount - oldcount,
388 locked_page != NULL);
366 unlock_super(sb); 389 unlock_super(sb);
367 UFSD("EXIT, result %u\n", result); 390 UFSD("EXIT, result %u\n", result);
368 return result; 391 return result;
@@ -398,6 +421,8 @@ unsigned ufs_new_fragments(struct inode * inode, __fs32 * p, unsigned fragment,
398 *p = cpu_to_fs32(sb, result); 421 *p = cpu_to_fs32(sb, result);
399 *err = 0; 422 *err = 0;
400 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count); 423 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
424 ufs_clear_frags(inode, result + oldcount, newcount - oldcount,
425 locked_page != NULL);
401 unlock_super(sb); 426 unlock_super(sb);
402 if (newcount < request) 427 if (newcount < request)
403 ufs_free_fragments (inode, result + newcount, request - newcount); 428 ufs_free_fragments (inode, result + newcount, request - newcount);
diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index ee1eaa6f4ec2..2fbab0aab688 100644
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -156,36 +156,6 @@ out:
156 return ret; 156 return ret;
157} 157}
158 158
159static void ufs_clear_frag(struct inode *inode, struct buffer_head *bh)
160{
161 lock_buffer(bh);
162 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
163 set_buffer_uptodate(bh);
164 mark_buffer_dirty(bh);
165 unlock_buffer(bh);
166 if (IS_SYNC(inode))
167 sync_dirty_buffer(bh);
168}
169
170static struct buffer_head *
171ufs_clear_frags(struct inode *inode, sector_t beg,
172 unsigned int n, sector_t want)
173{
174 struct buffer_head *res = NULL, *bh;
175 sector_t end = beg + n;
176
177 for (; beg < end; ++beg) {
178 bh = sb_getblk(inode->i_sb, beg);
179 ufs_clear_frag(inode, bh);
180 if (want != beg)
181 brelse(bh);
182 else
183 res = bh;
184 }
185 BUG_ON(!res);
186 return res;
187}
188
189/** 159/**
190 * ufs_inode_getfrag() - allocate new fragment(s) 160 * ufs_inode_getfrag() - allocate new fragment(s)
191 * @inode - pointer to inode 161 * @inode - pointer to inode
@@ -302,7 +272,7 @@ repeat:
302 } 272 }
303 273
304 if (!phys) { 274 if (!phys) {
305 result = ufs_clear_frags(inode, tmp, required, tmp + blockoff); 275 result = sb_getblk(sb, tmp + blockoff);
306 } else { 276 } else {
307 *phys = tmp + blockoff; 277 *phys = tmp + blockoff;
308 result = NULL; 278 result = NULL;
@@ -403,8 +373,7 @@ repeat:
403 373
404 374
405 if (!phys) { 375 if (!phys) {
406 result = ufs_clear_frags(inode, tmp, uspi->s_fpb, 376 result = sb_getblk(sb, tmp + blockoff);
407 tmp + blockoff);
408 } else { 377 } else {
409 *phys = tmp + blockoff; 378 *phys = tmp + blockoff;
410 *new = 1; 379 *new = 1;
@@ -471,13 +440,13 @@ int ufs_getfrag_block(struct inode *inode, sector_t fragment, struct buffer_head
471#define GET_INODE_DATABLOCK(x) \ 440#define GET_INODE_DATABLOCK(x) \
472 ufs_inode_getfrag(inode, x, fragment, 1, &err, &phys, &new, bh_result->b_page) 441 ufs_inode_getfrag(inode, x, fragment, 1, &err, &phys, &new, bh_result->b_page)
473#define GET_INODE_PTR(x) \ 442#define GET_INODE_PTR(x) \
474 ufs_inode_getfrag(inode, x, fragment, uspi->s_fpb, &err, NULL, NULL, bh_result->b_page) 443 ufs_inode_getfrag(inode, x, fragment, uspi->s_fpb, &err, NULL, NULL, NULL)
475#define GET_INDIRECT_DATABLOCK(x) \ 444#define GET_INDIRECT_DATABLOCK(x) \
476 ufs_inode_getblock(inode, bh, x, fragment, \ 445 ufs_inode_getblock(inode, bh, x, fragment, \
477 &err, &phys, &new, bh_result->b_page); 446 &err, &phys, &new, bh_result->b_page)
478#define GET_INDIRECT_PTR(x) \ 447#define GET_INDIRECT_PTR(x) \
479 ufs_inode_getblock(inode, bh, x, fragment, \ 448 ufs_inode_getblock(inode, bh, x, fragment, \
480 &err, NULL, NULL, bh_result->b_page); 449 &err, NULL, NULL, NULL)
481 450
482 if (ptr < UFS_NDIR_FRAGMENT) { 451 if (ptr < UFS_NDIR_FRAGMENT) {
483 bh = GET_INODE_DATABLOCK(ptr); 452 bh = GET_INODE_DATABLOCK(ptr);
generated by cgit v1.2.2 (git 2.25.0) at 2025-10-10 06:40:16 -0400