diff options
Diffstat (limited to 'fs')
128 files changed, 1482 insertions, 839 deletions
diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c index cf62b05e296a..7d6c2139891d 100644 --- a/fs/9p/v9fs.c +++ b/fs/9p/v9fs.c | |||
@@ -84,7 +84,7 @@ static const match_table_t tokens = { | |||
84 | 84 | ||
85 | static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts) | 85 | static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts) |
86 | { | 86 | { |
87 | char *options; | 87 | char *options, *tmp_options; |
88 | substring_t args[MAX_OPT_ARGS]; | 88 | substring_t args[MAX_OPT_ARGS]; |
89 | char *p; | 89 | char *p; |
90 | int option = 0; | 90 | int option = 0; |
@@ -102,9 +102,12 @@ static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts) | |||
102 | if (!opts) | 102 | if (!opts) |
103 | return 0; | 103 | return 0; |
104 | 104 | ||
105 | options = kstrdup(opts, GFP_KERNEL); | 105 | tmp_options = kstrdup(opts, GFP_KERNEL); |
106 | if (!options) | 106 | if (!tmp_options) { |
107 | ret = -ENOMEM; | ||
107 | goto fail_option_alloc; | 108 | goto fail_option_alloc; |
109 | } | ||
110 | options = tmp_options; | ||
108 | 111 | ||
109 | while ((p = strsep(&options, ",")) != NULL) { | 112 | while ((p = strsep(&options, ",")) != NULL) { |
110 | int token; | 113 | int token; |
@@ -159,8 +162,12 @@ static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts) | |||
159 | break; | 162 | break; |
160 | case Opt_cache: | 163 | case Opt_cache: |
161 | s = match_strdup(&args[0]); | 164 | s = match_strdup(&args[0]); |
162 | if (!s) | 165 | if (!s) { |
163 | goto fail_option_alloc; | 166 | ret = -ENOMEM; |
167 | P9_DPRINTK(P9_DEBUG_ERROR, | ||
168 | "problem allocating copy of cache arg\n"); | ||
169 | goto free_and_return; | ||
170 | } | ||
164 | 171 | ||
165 | if (strcmp(s, "loose") == 0) | 172 | if (strcmp(s, "loose") == 0) |
166 | v9ses->cache = CACHE_LOOSE; | 173 | v9ses->cache = CACHE_LOOSE; |
@@ -173,8 +180,12 @@ static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts) | |||
173 | 180 | ||
174 | case Opt_access: | 181 | case Opt_access: |
175 | s = match_strdup(&args[0]); | 182 | s = match_strdup(&args[0]); |
176 | if (!s) | 183 | if (!s) { |
177 | goto fail_option_alloc; | 184 | ret = -ENOMEM; |
185 | P9_DPRINTK(P9_DEBUG_ERROR, | ||
186 | "problem allocating copy of access arg\n"); | ||
187 | goto free_and_return; | ||
188 | } | ||
178 | 189 | ||
179 | v9ses->flags &= ~V9FS_ACCESS_MASK; | 190 | v9ses->flags &= ~V9FS_ACCESS_MASK; |
180 | if (strcmp(s, "user") == 0) | 191 | if (strcmp(s, "user") == 0) |
@@ -194,13 +205,11 @@ static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts) | |||
194 | continue; | 205 | continue; |
195 | } | 206 | } |
196 | } | 207 | } |
197 | kfree(options); | ||
198 | return ret; | ||
199 | 208 | ||
209 | free_and_return: | ||
210 | kfree(tmp_options); | ||
200 | fail_option_alloc: | 211 | fail_option_alloc: |
201 | P9_DPRINTK(P9_DEBUG_ERROR, | 212 | return ret; |
202 | "failed to allocate copy of option argument\n"); | ||
203 | return -ENOMEM; | ||
204 | } | 213 | } |
205 | 214 | ||
206 | /** | 215 | /** |
diff --git a/fs/9p/v9fs_vfs.h b/fs/9p/v9fs_vfs.h index 3a7560e35865..ed835836e0dc 100644 --- a/fs/9p/v9fs_vfs.h +++ b/fs/9p/v9fs_vfs.h | |||
@@ -60,3 +60,4 @@ void v9fs_dentry_release(struct dentry *); | |||
60 | int v9fs_uflags2omode(int uflags, int extended); | 60 | int v9fs_uflags2omode(int uflags, int extended); |
61 | 61 | ||
62 | ssize_t v9fs_file_readn(struct file *, char *, char __user *, u32, u64); | 62 | ssize_t v9fs_file_readn(struct file *, char *, char __user *, u32, u64); |
63 | void v9fs_blank_wstat(struct p9_wstat *wstat); | ||
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c index 3902bf43a088..74a0461a9ac0 100644 --- a/fs/9p/vfs_file.c +++ b/fs/9p/vfs_file.c | |||
@@ -257,6 +257,23 @@ v9fs_file_write(struct file *filp, const char __user * data, | |||
257 | return total; | 257 | return total; |
258 | } | 258 | } |
259 | 259 | ||
260 | static int v9fs_file_fsync(struct file *filp, struct dentry *dentry, | ||
261 | int datasync) | ||
262 | { | ||
263 | struct p9_fid *fid; | ||
264 | struct p9_wstat wstat; | ||
265 | int retval; | ||
266 | |||
267 | P9_DPRINTK(P9_DEBUG_VFS, "filp %p dentry %p datasync %x\n", filp, | ||
268 | dentry, datasync); | ||
269 | |||
270 | fid = filp->private_data; | ||
271 | v9fs_blank_wstat(&wstat); | ||
272 | |||
273 | retval = p9_client_wstat(fid, &wstat); | ||
274 | return retval; | ||
275 | } | ||
276 | |||
260 | static const struct file_operations v9fs_cached_file_operations = { | 277 | static const struct file_operations v9fs_cached_file_operations = { |
261 | .llseek = generic_file_llseek, | 278 | .llseek = generic_file_llseek, |
262 | .read = do_sync_read, | 279 | .read = do_sync_read, |
@@ -266,6 +283,7 @@ static const struct file_operations v9fs_cached_file_operations = { | |||
266 | .release = v9fs_dir_release, | 283 | .release = v9fs_dir_release, |
267 | .lock = v9fs_file_lock, | 284 | .lock = v9fs_file_lock, |
268 | .mmap = generic_file_readonly_mmap, | 285 | .mmap = generic_file_readonly_mmap, |
286 | .fsync = v9fs_file_fsync, | ||
269 | }; | 287 | }; |
270 | 288 | ||
271 | const struct file_operations v9fs_file_operations = { | 289 | const struct file_operations v9fs_file_operations = { |
@@ -276,4 +294,5 @@ const struct file_operations v9fs_file_operations = { | |||
276 | .release = v9fs_dir_release, | 294 | .release = v9fs_dir_release, |
277 | .lock = v9fs_file_lock, | 295 | .lock = v9fs_file_lock, |
278 | .mmap = generic_file_readonly_mmap, | 296 | .mmap = generic_file_readonly_mmap, |
297 | .fsync = v9fs_file_fsync, | ||
279 | }; | 298 | }; |
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c index 18f74ec4dce9..a407fa3388c0 100644 --- a/fs/9p/vfs_inode.c +++ b/fs/9p/vfs_inode.c | |||
@@ -176,7 +176,7 @@ int v9fs_uflags2omode(int uflags, int extended) | |||
176 | * | 176 | * |
177 | */ | 177 | */ |
178 | 178 | ||
179 | static void | 179 | void |
180 | v9fs_blank_wstat(struct p9_wstat *wstat) | 180 | v9fs_blank_wstat(struct p9_wstat *wstat) |
181 | { | 181 | { |
182 | wstat->type = ~0; | 182 | wstat->type = ~0; |
@@ -1001,44 +1001,6 @@ done: | |||
1001 | } | 1001 | } |
1002 | 1002 | ||
1003 | /** | 1003 | /** |
1004 | * v9fs_vfs_readlink - read a symlink's location | ||
1005 | * @dentry: dentry for symlink | ||
1006 | * @buffer: buffer to load symlink location into | ||
1007 | * @buflen: length of buffer | ||
1008 | * | ||
1009 | */ | ||
1010 | |||
1011 | static int v9fs_vfs_readlink(struct dentry *dentry, char __user * buffer, | ||
1012 | int buflen) | ||
1013 | { | ||
1014 | int retval; | ||
1015 | int ret; | ||
1016 | char *link = __getname(); | ||
1017 | |||
1018 | if (unlikely(!link)) | ||
1019 | return -ENOMEM; | ||
1020 | |||
1021 | if (buflen > PATH_MAX) | ||
1022 | buflen = PATH_MAX; | ||
1023 | |||
1024 | P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_name.name, | ||
1025 | dentry); | ||
1026 | |||
1027 | retval = v9fs_readlink(dentry, link, buflen); | ||
1028 | |||
1029 | if (retval > 0) { | ||
1030 | if ((ret = copy_to_user(buffer, link, retval)) != 0) { | ||
1031 | P9_DPRINTK(P9_DEBUG_ERROR, | ||
1032 | "problem copying to user: %d\n", ret); | ||
1033 | retval = ret; | ||
1034 | } | ||
1035 | } | ||
1036 | |||
1037 | __putname(link); | ||
1038 | return retval; | ||
1039 | } | ||
1040 | |||
1041 | /** | ||
1042 | * v9fs_vfs_follow_link - follow a symlink path | 1004 | * v9fs_vfs_follow_link - follow a symlink path |
1043 | * @dentry: dentry for symlink | 1005 | * @dentry: dentry for symlink |
1044 | * @nd: nameidata | 1006 | * @nd: nameidata |
@@ -1230,7 +1192,6 @@ static const struct inode_operations v9fs_dir_inode_operations_ext = { | |||
1230 | .rmdir = v9fs_vfs_rmdir, | 1192 | .rmdir = v9fs_vfs_rmdir, |
1231 | .mknod = v9fs_vfs_mknod, | 1193 | .mknod = v9fs_vfs_mknod, |
1232 | .rename = v9fs_vfs_rename, | 1194 | .rename = v9fs_vfs_rename, |
1233 | .readlink = v9fs_vfs_readlink, | ||
1234 | .getattr = v9fs_vfs_getattr, | 1195 | .getattr = v9fs_vfs_getattr, |
1235 | .setattr = v9fs_vfs_setattr, | 1196 | .setattr = v9fs_vfs_setattr, |
1236 | }; | 1197 | }; |
@@ -1253,7 +1214,7 @@ static const struct inode_operations v9fs_file_inode_operations = { | |||
1253 | }; | 1214 | }; |
1254 | 1215 | ||
1255 | static const struct inode_operations v9fs_symlink_inode_operations = { | 1216 | static const struct inode_operations v9fs_symlink_inode_operations = { |
1256 | .readlink = v9fs_vfs_readlink, | 1217 | .readlink = generic_readlink, |
1257 | .follow_link = v9fs_vfs_follow_link, | 1218 | .follow_link = v9fs_vfs_follow_link, |
1258 | .put_link = v9fs_vfs_put_link, | 1219 | .put_link = v9fs_vfs_put_link, |
1259 | .getattr = v9fs_vfs_getattr, | 1220 | .getattr = v9fs_vfs_getattr, |
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c index 14a86448572c..69357c0d9899 100644 --- a/fs/9p/vfs_super.c +++ b/fs/9p/vfs_super.c | |||
@@ -188,7 +188,8 @@ static void v9fs_kill_super(struct super_block *s) | |||
188 | 188 | ||
189 | P9_DPRINTK(P9_DEBUG_VFS, " %p\n", s); | 189 | P9_DPRINTK(P9_DEBUG_VFS, " %p\n", s); |
190 | 190 | ||
191 | v9fs_dentry_release(s->s_root); /* clunk root */ | 191 | if (s->s_root) |
192 | v9fs_dentry_release(s->s_root); /* clunk root */ | ||
192 | 193 | ||
193 | kill_anon_super(s); | 194 | kill_anon_super(s); |
194 | 195 | ||
diff --git a/fs/affs/affs.h b/fs/affs/affs.h index e511dc621a2e..0e40caaba456 100644 --- a/fs/affs/affs.h +++ b/fs/affs/affs.h | |||
@@ -106,8 +106,8 @@ struct affs_sb_info { | |||
106 | u32 s_last_bmap; | 106 | u32 s_last_bmap; |
107 | struct buffer_head *s_bmap_bh; | 107 | struct buffer_head *s_bmap_bh; |
108 | char *s_prefix; /* Prefix for volumes and assigns. */ | 108 | char *s_prefix; /* Prefix for volumes and assigns. */ |
109 | int s_prefix_len; /* Length of prefix. */ | ||
110 | char s_volume[32]; /* Volume prefix for absolute symlinks. */ | 109 | char s_volume[32]; /* Volume prefix for absolute symlinks. */ |
110 | spinlock_t symlink_lock; /* protects the previous two */ | ||
111 | }; | 111 | }; |
112 | 112 | ||
113 | #define SF_INTL 0x0001 /* International filesystem. */ | 113 | #define SF_INTL 0x0001 /* International filesystem. */ |
diff --git a/fs/affs/namei.c b/fs/affs/namei.c index 960d336ec694..d70bbbac6b7b 100644 --- a/fs/affs/namei.c +++ b/fs/affs/namei.c | |||
@@ -341,10 +341,13 @@ affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) | |||
341 | p = (char *)AFFS_HEAD(bh)->table; | 341 | p = (char *)AFFS_HEAD(bh)->table; |
342 | lc = '/'; | 342 | lc = '/'; |
343 | if (*symname == '/') { | 343 | if (*symname == '/') { |
344 | struct affs_sb_info *sbi = AFFS_SB(sb); | ||
344 | while (*symname == '/') | 345 | while (*symname == '/') |
345 | symname++; | 346 | symname++; |
346 | while (AFFS_SB(sb)->s_volume[i]) /* Cannot overflow */ | 347 | spin_lock(&sbi->symlink_lock); |
347 | *p++ = AFFS_SB(sb)->s_volume[i++]; | 348 | while (sbi->s_volume[i]) /* Cannot overflow */ |
349 | *p++ = sbi->s_volume[i++]; | ||
350 | spin_unlock(&sbi->symlink_lock); | ||
348 | } | 351 | } |
349 | while (i < maxlen && (c = *symname++)) { | 352 | while (i < maxlen && (c = *symname++)) { |
350 | if (c == '.' && lc == '/' && *symname == '.' && symname[1] == '/') { | 353 | if (c == '.' && lc == '/' && *symname == '.' && symname[1] == '/') { |
diff --git a/fs/affs/super.c b/fs/affs/super.c index 104fdcb3a7fc..d41e9673cd97 100644 --- a/fs/affs/super.c +++ b/fs/affs/super.c | |||
@@ -203,7 +203,7 @@ parse_options(char *options, uid_t *uid, gid_t *gid, int *mode, int *reserved, s | |||
203 | switch (token) { | 203 | switch (token) { |
204 | case Opt_bs: | 204 | case Opt_bs: |
205 | if (match_int(&args[0], &n)) | 205 | if (match_int(&args[0], &n)) |
206 | return -EINVAL; | 206 | return 0; |
207 | if (n != 512 && n != 1024 && n != 2048 | 207 | if (n != 512 && n != 1024 && n != 2048 |
208 | && n != 4096) { | 208 | && n != 4096) { |
209 | printk ("AFFS: Invalid blocksize (512, 1024, 2048, 4096 allowed)\n"); | 209 | printk ("AFFS: Invalid blocksize (512, 1024, 2048, 4096 allowed)\n"); |
@@ -213,7 +213,7 @@ parse_options(char *options, uid_t *uid, gid_t *gid, int *mode, int *reserved, s | |||
213 | break; | 213 | break; |
214 | case Opt_mode: | 214 | case Opt_mode: |
215 | if (match_octal(&args[0], &option)) | 215 | if (match_octal(&args[0], &option)) |
216 | return 1; | 216 | return 0; |
217 | *mode = option & 0777; | 217 | *mode = option & 0777; |
218 | *mount_opts |= SF_SETMODE; | 218 | *mount_opts |= SF_SETMODE; |
219 | break; | 219 | break; |
@@ -221,8 +221,6 @@ parse_options(char *options, uid_t *uid, gid_t *gid, int *mode, int *reserved, s | |||
221 | *mount_opts |= SF_MUFS; | 221 | *mount_opts |= SF_MUFS; |
222 | break; | 222 | break; |
223 | case Opt_prefix: | 223 | case Opt_prefix: |
224 | /* Free any previous prefix */ | ||
225 | kfree(*prefix); | ||
226 | *prefix = match_strdup(&args[0]); | 224 | *prefix = match_strdup(&args[0]); |
227 | if (!*prefix) | 225 | if (!*prefix) |
228 | return 0; | 226 | return 0; |
@@ -233,21 +231,21 @@ parse_options(char *options, uid_t *uid, gid_t *gid, int *mode, int *reserved, s | |||
233 | break; | 231 | break; |
234 | case Opt_reserved: | 232 | case Opt_reserved: |
235 | if (match_int(&args[0], reserved)) | 233 | if (match_int(&args[0], reserved)) |
236 | return 1; | 234 | return 0; |
237 | break; | 235 | break; |
238 | case Opt_root: | 236 | case Opt_root: |
239 | if (match_int(&args[0], root)) | 237 | if (match_int(&args[0], root)) |
240 | return 1; | 238 | return 0; |
241 | break; | 239 | break; |
242 | case Opt_setgid: | 240 | case Opt_setgid: |
243 | if (match_int(&args[0], &option)) | 241 | if (match_int(&args[0], &option)) |
244 | return 1; | 242 | return 0; |
245 | *gid = option; | 243 | *gid = option; |
246 | *mount_opts |= SF_SETGID; | 244 | *mount_opts |= SF_SETGID; |
247 | break; | 245 | break; |
248 | case Opt_setuid: | 246 | case Opt_setuid: |
249 | if (match_int(&args[0], &option)) | 247 | if (match_int(&args[0], &option)) |
250 | return -EINVAL; | 248 | return 0; |
251 | *uid = option; | 249 | *uid = option; |
252 | *mount_opts |= SF_SETUID; | 250 | *mount_opts |= SF_SETUID; |
253 | break; | 251 | break; |
@@ -311,11 +309,14 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent) | |||
311 | return -ENOMEM; | 309 | return -ENOMEM; |
312 | sb->s_fs_info = sbi; | 310 | sb->s_fs_info = sbi; |
313 | mutex_init(&sbi->s_bmlock); | 311 | mutex_init(&sbi->s_bmlock); |
312 | spin_lock_init(&sbi->symlink_lock); | ||
314 | 313 | ||
315 | if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block, | 314 | if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block, |
316 | &blocksize,&sbi->s_prefix, | 315 | &blocksize,&sbi->s_prefix, |
317 | sbi->s_volume, &mount_flags)) { | 316 | sbi->s_volume, &mount_flags)) { |
318 | printk(KERN_ERR "AFFS: Error parsing options\n"); | 317 | printk(KERN_ERR "AFFS: Error parsing options\n"); |
318 | kfree(sbi->s_prefix); | ||
319 | kfree(sbi); | ||
319 | return -EINVAL; | 320 | return -EINVAL; |
320 | } | 321 | } |
321 | /* N.B. after this point s_prefix must be released */ | 322 | /* N.B. after this point s_prefix must be released */ |
@@ -516,14 +517,18 @@ affs_remount(struct super_block *sb, int *flags, char *data) | |||
516 | unsigned long mount_flags; | 517 | unsigned long mount_flags; |
517 | int res = 0; | 518 | int res = 0; |
518 | char *new_opts = kstrdup(data, GFP_KERNEL); | 519 | char *new_opts = kstrdup(data, GFP_KERNEL); |
520 | char volume[32]; | ||
521 | char *prefix = NULL; | ||
519 | 522 | ||
520 | pr_debug("AFFS: remount(flags=0x%x,opts=\"%s\")\n",*flags,data); | 523 | pr_debug("AFFS: remount(flags=0x%x,opts=\"%s\")\n",*flags,data); |
521 | 524 | ||
522 | *flags |= MS_NODIRATIME; | 525 | *flags |= MS_NODIRATIME; |
523 | 526 | ||
527 | memcpy(volume, sbi->s_volume, 32); | ||
524 | if (!parse_options(data, &uid, &gid, &mode, &reserved, &root_block, | 528 | if (!parse_options(data, &uid, &gid, &mode, &reserved, &root_block, |
525 | &blocksize, &sbi->s_prefix, sbi->s_volume, | 529 | &blocksize, &prefix, volume, |
526 | &mount_flags)) { | 530 | &mount_flags)) { |
531 | kfree(prefix); | ||
527 | kfree(new_opts); | 532 | kfree(new_opts); |
528 | return -EINVAL; | 533 | return -EINVAL; |
529 | } | 534 | } |
@@ -534,6 +539,14 @@ affs_remount(struct super_block *sb, int *flags, char *data) | |||
534 | sbi->s_mode = mode; | 539 | sbi->s_mode = mode; |
535 | sbi->s_uid = uid; | 540 | sbi->s_uid = uid; |
536 | sbi->s_gid = gid; | 541 | sbi->s_gid = gid; |
542 | /* protect against readers */ | ||
543 | spin_lock(&sbi->symlink_lock); | ||
544 | if (prefix) { | ||
545 | kfree(sbi->s_prefix); | ||
546 | sbi->s_prefix = prefix; | ||
547 | } | ||
548 | memcpy(sbi->s_volume, volume, 32); | ||
549 | spin_unlock(&sbi->symlink_lock); | ||
537 | 550 | ||
538 | if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) { | 551 | if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) { |
539 | unlock_kernel(); | 552 | unlock_kernel(); |
diff --git a/fs/affs/symlink.c b/fs/affs/symlink.c index 41782539c907..ee00f08c4f53 100644 --- a/fs/affs/symlink.c +++ b/fs/affs/symlink.c | |||
@@ -20,7 +20,6 @@ static int affs_symlink_readpage(struct file *file, struct page *page) | |||
20 | int i, j; | 20 | int i, j; |
21 | char c; | 21 | char c; |
22 | char lc; | 22 | char lc; |
23 | char *pf; | ||
24 | 23 | ||
25 | pr_debug("AFFS: follow_link(ino=%lu)\n",inode->i_ino); | 24 | pr_debug("AFFS: follow_link(ino=%lu)\n",inode->i_ino); |
26 | 25 | ||
@@ -32,11 +31,15 @@ static int affs_symlink_readpage(struct file *file, struct page *page) | |||
32 | j = 0; | 31 | j = 0; |
33 | lf = (struct slink_front *)bh->b_data; | 32 | lf = (struct slink_front *)bh->b_data; |
34 | lc = 0; | 33 | lc = 0; |
35 | pf = AFFS_SB(inode->i_sb)->s_prefix ? AFFS_SB(inode->i_sb)->s_prefix : "/"; | ||
36 | 34 | ||
37 | if (strchr(lf->symname,':')) { /* Handle assign or volume name */ | 35 | if (strchr(lf->symname,':')) { /* Handle assign or volume name */ |
36 | struct affs_sb_info *sbi = AFFS_SB(inode->i_sb); | ||
37 | char *pf; | ||
38 | spin_lock(&sbi->symlink_lock); | ||
39 | pf = sbi->s_prefix ? sbi->s_prefix : "/"; | ||
38 | while (i < 1023 && (c = pf[i])) | 40 | while (i < 1023 && (c = pf[i])) |
39 | link[i++] = c; | 41 | link[i++] = c; |
42 | spin_unlock(&sbi->symlink_lock); | ||
40 | while (i < 1023 && lf->symname[j] != ':') | 43 | while (i < 1023 && lf->symname[j] != ':') |
41 | link[i++] = lf->symname[j++]; | 44 | link[i++] = lf->symname[j++]; |
42 | if (i < 1023) | 45 | if (i < 1023) |
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c index 33baf27fac78..34ddda888e63 100644 --- a/fs/befs/linuxvfs.c +++ b/fs/befs/linuxvfs.c | |||
@@ -873,6 +873,7 @@ befs_fill_super(struct super_block *sb, void *data, int silent) | |||
873 | brelse(bh); | 873 | brelse(bh); |
874 | 874 | ||
875 | unacquire_priv_sbp: | 875 | unacquire_priv_sbp: |
876 | kfree(befs_sb->mount_opts.iocharset); | ||
876 | kfree(sb->s_fs_info); | 877 | kfree(sb->s_fs_info); |
877 | 878 | ||
878 | unacquire_none: | 879 | unacquire_none: |
diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c index 6f60336c6628..8f3d9fd89604 100644 --- a/fs/bfs/inode.c +++ b/fs/bfs/inode.c | |||
@@ -353,35 +353,35 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent) | |||
353 | struct inode *inode; | 353 | struct inode *inode; |
354 | unsigned i, imap_len; | 354 | unsigned i, imap_len; |
355 | struct bfs_sb_info *info; | 355 | struct bfs_sb_info *info; |
356 | long ret = -EINVAL; | 356 | int ret = -EINVAL; |
357 | unsigned long i_sblock, i_eblock, i_eoff, s_size; | 357 | unsigned long i_sblock, i_eblock, i_eoff, s_size; |
358 | 358 | ||
359 | info = kzalloc(sizeof(*info), GFP_KERNEL); | 359 | info = kzalloc(sizeof(*info), GFP_KERNEL); |
360 | if (!info) | 360 | if (!info) |
361 | return -ENOMEM; | 361 | return -ENOMEM; |
362 | mutex_init(&info->bfs_lock); | ||
362 | s->s_fs_info = info; | 363 | s->s_fs_info = info; |
363 | 364 | ||
364 | sb_set_blocksize(s, BFS_BSIZE); | 365 | sb_set_blocksize(s, BFS_BSIZE); |
365 | 366 | ||
366 | bh = sb_bread(s, 0); | 367 | info->si_sbh = sb_bread(s, 0); |
367 | if(!bh) | 368 | if (!info->si_sbh) |
368 | goto out; | 369 | goto out; |
369 | bfs_sb = (struct bfs_super_block *)bh->b_data; | 370 | bfs_sb = (struct bfs_super_block *)info->si_sbh->b_data; |
370 | if (le32_to_cpu(bfs_sb->s_magic) != BFS_MAGIC) { | 371 | if (le32_to_cpu(bfs_sb->s_magic) != BFS_MAGIC) { |
371 | if (!silent) | 372 | if (!silent) |
372 | printf("No BFS filesystem on %s (magic=%08x)\n", | 373 | printf("No BFS filesystem on %s (magic=%08x)\n", |
373 | s->s_id, le32_to_cpu(bfs_sb->s_magic)); | 374 | s->s_id, le32_to_cpu(bfs_sb->s_magic)); |
374 | goto out; | 375 | goto out1; |
375 | } | 376 | } |
376 | if (BFS_UNCLEAN(bfs_sb, s) && !silent) | 377 | if (BFS_UNCLEAN(bfs_sb, s) && !silent) |
377 | printf("%s is unclean, continuing\n", s->s_id); | 378 | printf("%s is unclean, continuing\n", s->s_id); |
378 | 379 | ||
379 | s->s_magic = BFS_MAGIC; | 380 | s->s_magic = BFS_MAGIC; |
380 | info->si_sbh = bh; | ||
381 | 381 | ||
382 | if (le32_to_cpu(bfs_sb->s_start) > le32_to_cpu(bfs_sb->s_end)) { | 382 | if (le32_to_cpu(bfs_sb->s_start) > le32_to_cpu(bfs_sb->s_end)) { |
383 | printf("Superblock is corrupted\n"); | 383 | printf("Superblock is corrupted\n"); |
384 | goto out; | 384 | goto out1; |
385 | } | 385 | } |
386 | 386 | ||
387 | info->si_lasti = (le32_to_cpu(bfs_sb->s_start) - BFS_BSIZE) / | 387 | info->si_lasti = (le32_to_cpu(bfs_sb->s_start) - BFS_BSIZE) / |
@@ -390,7 +390,7 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent) | |||
390 | imap_len = (info->si_lasti / 8) + 1; | 390 | imap_len = (info->si_lasti / 8) + 1; |
391 | info->si_imap = kzalloc(imap_len, GFP_KERNEL); | 391 | info->si_imap = kzalloc(imap_len, GFP_KERNEL); |
392 | if (!info->si_imap) | 392 | if (!info->si_imap) |
393 | goto out; | 393 | goto out1; |
394 | for (i = 0; i < BFS_ROOT_INO; i++) | 394 | for (i = 0; i < BFS_ROOT_INO; i++) |
395 | set_bit(i, info->si_imap); | 395 | set_bit(i, info->si_imap); |
396 | 396 | ||
@@ -398,15 +398,13 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent) | |||
398 | inode = bfs_iget(s, BFS_ROOT_INO); | 398 | inode = bfs_iget(s, BFS_ROOT_INO); |
399 | if (IS_ERR(inode)) { | 399 | if (IS_ERR(inode)) { |
400 | ret = PTR_ERR(inode); | 400 | ret = PTR_ERR(inode); |
401 | kfree(info->si_imap); | 401 | goto out2; |
402 | goto out; | ||
403 | } | 402 | } |
404 | s->s_root = d_alloc_root(inode); | 403 | s->s_root = d_alloc_root(inode); |
405 | if (!s->s_root) { | 404 | if (!s->s_root) { |
406 | iput(inode); | 405 | iput(inode); |
407 | ret = -ENOMEM; | 406 | ret = -ENOMEM; |
408 | kfree(info->si_imap); | 407 | goto out2; |
409 | goto out; | ||
410 | } | 408 | } |
411 | 409 | ||
412 | info->si_blocks = (le32_to_cpu(bfs_sb->s_end) + 1) >> BFS_BSIZE_BITS; | 410 | info->si_blocks = (le32_to_cpu(bfs_sb->s_end) + 1) >> BFS_BSIZE_BITS; |
@@ -419,10 +417,8 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent) | |||
419 | bh = sb_bread(s, info->si_blocks - 1); | 417 | bh = sb_bread(s, info->si_blocks - 1); |
420 | if (!bh) { | 418 | if (!bh) { |
421 | printf("Last block not available: %lu\n", info->si_blocks - 1); | 419 | printf("Last block not available: %lu\n", info->si_blocks - 1); |
422 | iput(inode); | ||
423 | ret = -EIO; | 420 | ret = -EIO; |
424 | kfree(info->si_imap); | 421 | goto out3; |
425 | goto out; | ||
426 | } | 422 | } |
427 | brelse(bh); | 423 | brelse(bh); |
428 | 424 | ||
@@ -459,11 +455,8 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent) | |||
459 | printf("Inode 0x%08x corrupted\n", i); | 455 | printf("Inode 0x%08x corrupted\n", i); |
460 | 456 | ||
461 | brelse(bh); | 457 | brelse(bh); |
462 | s->s_root = NULL; | 458 | ret = -EIO; |
463 | kfree(info->si_imap); | 459 | goto out3; |
464 | kfree(info); | ||
465 | s->s_fs_info = NULL; | ||
466 | return -EIO; | ||
467 | } | 460 | } |
468 | 461 | ||
469 | if (!di->i_ino) { | 462 | if (!di->i_ino) { |
@@ -483,11 +476,17 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent) | |||
483 | s->s_dirt = 1; | 476 | s->s_dirt = 1; |
484 | } | 477 | } |
485 | dump_imap("read_super", s); | 478 | dump_imap("read_super", s); |
486 | mutex_init(&info->bfs_lock); | ||
487 | return 0; | 479 | return 0; |
488 | 480 | ||
481 | out3: | ||
482 | dput(s->s_root); | ||
483 | s->s_root = NULL; | ||
484 | out2: | ||
485 | kfree(info->si_imap); | ||
486 | out1: | ||
487 | brelse(info->si_sbh); | ||
489 | out: | 488 | out: |
490 | brelse(bh); | 489 | mutex_destroy(&info->bfs_lock); |
491 | kfree(info); | 490 | kfree(info); |
492 | s->s_fs_info = NULL; | 491 | s->s_fs_info = NULL; |
493 | return ret; | 492 | return ret; |
diff --git a/fs/binfmt_aout.c b/fs/binfmt_aout.c index 346b69405363..fdd397099172 100644 --- a/fs/binfmt_aout.c +++ b/fs/binfmt_aout.c | |||
@@ -264,6 +264,7 @@ static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs) | |||
264 | #else | 264 | #else |
265 | set_personality(PER_LINUX); | 265 | set_personality(PER_LINUX); |
266 | #endif | 266 | #endif |
267 | setup_new_exec(bprm); | ||
267 | 268 | ||
268 | current->mm->end_code = ex.a_text + | 269 | current->mm->end_code = ex.a_text + |
269 | (current->mm->start_code = N_TXTADDR(ex)); | 270 | (current->mm->start_code = N_TXTADDR(ex)); |
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c index edd90c49003c..fd5b2ea5d299 100644 --- a/fs/binfmt_elf.c +++ b/fs/binfmt_elf.c | |||
@@ -662,27 +662,6 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs) | |||
662 | if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0') | 662 | if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0') |
663 | goto out_free_interp; | 663 | goto out_free_interp; |
664 | 664 | ||
665 | /* | ||
666 | * The early SET_PERSONALITY here is so that the lookup | ||
667 | * for the interpreter happens in the namespace of the | ||
668 | * to-be-execed image. SET_PERSONALITY can select an | ||
669 | * alternate root. | ||
670 | * | ||
671 | * However, SET_PERSONALITY is NOT allowed to switch | ||
672 | * this task into the new images's memory mapping | ||
673 | * policy - that is, TASK_SIZE must still evaluate to | ||
674 | * that which is appropriate to the execing application. | ||
675 | * This is because exit_mmap() needs to have TASK_SIZE | ||
676 | * evaluate to the size of the old image. | ||
677 | * | ||
678 | * So if (say) a 64-bit application is execing a 32-bit | ||
679 | * application it is the architecture's responsibility | ||
680 | * to defer changing the value of TASK_SIZE until the | ||
681 | * switch really is going to happen - do this in | ||
682 | * flush_thread(). - akpm | ||
683 | */ | ||
684 | SET_PERSONALITY(loc->elf_ex); | ||
685 | |||
686 | interpreter = open_exec(elf_interpreter); | 665 | interpreter = open_exec(elf_interpreter); |
687 | retval = PTR_ERR(interpreter); | 666 | retval = PTR_ERR(interpreter); |
688 | if (IS_ERR(interpreter)) | 667 | if (IS_ERR(interpreter)) |
@@ -730,9 +709,6 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs) | |||
730 | /* Verify the interpreter has a valid arch */ | 709 | /* Verify the interpreter has a valid arch */ |
731 | if (!elf_check_arch(&loc->interp_elf_ex)) | 710 | if (!elf_check_arch(&loc->interp_elf_ex)) |
732 | goto out_free_dentry; | 711 | goto out_free_dentry; |
733 | } else { | ||
734 | /* Executables without an interpreter also need a personality */ | ||
735 | SET_PERSONALITY(loc->elf_ex); | ||
736 | } | 712 | } |
737 | 713 | ||
738 | /* Flush all traces of the currently running executable */ | 714 | /* Flush all traces of the currently running executable */ |
@@ -752,7 +728,8 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs) | |||
752 | 728 | ||
753 | if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space) | 729 | if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space) |
754 | current->flags |= PF_RANDOMIZE; | 730 | current->flags |= PF_RANDOMIZE; |
755 | arch_pick_mmap_layout(current->mm); | 731 | |
732 | setup_new_exec(bprm); | ||
756 | 733 | ||
757 | /* Do this so that we can load the interpreter, if need be. We will | 734 | /* Do this so that we can load the interpreter, if need be. We will |
758 | change some of these later */ | 735 | change some of these later */ |
diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c index c57d9ce5ff7e..18d77297ccc8 100644 --- a/fs/binfmt_elf_fdpic.c +++ b/fs/binfmt_elf_fdpic.c | |||
@@ -321,6 +321,9 @@ static int load_elf_fdpic_binary(struct linux_binprm *bprm, | |||
321 | set_personality(PER_LINUX_FDPIC); | 321 | set_personality(PER_LINUX_FDPIC); |
322 | if (elf_read_implies_exec(&exec_params.hdr, executable_stack)) | 322 | if (elf_read_implies_exec(&exec_params.hdr, executable_stack)) |
323 | current->personality |= READ_IMPLIES_EXEC; | 323 | current->personality |= READ_IMPLIES_EXEC; |
324 | |||
325 | setup_new_exec(bprm); | ||
326 | |||
324 | set_binfmt(&elf_fdpic_format); | 327 | set_binfmt(&elf_fdpic_format); |
325 | 328 | ||
326 | current->mm->start_code = 0; | 329 | current->mm->start_code = 0; |
diff --git a/fs/binfmt_flat.c b/fs/binfmt_flat.c index d4a00ea1054c..42c6b4a54445 100644 --- a/fs/binfmt_flat.c +++ b/fs/binfmt_flat.c | |||
@@ -519,6 +519,7 @@ static int load_flat_file(struct linux_binprm * bprm, | |||
519 | 519 | ||
520 | /* OK, This is the point of no return */ | 520 | /* OK, This is the point of no return */ |
521 | set_personality(PER_LINUX_32BIT); | 521 | set_personality(PER_LINUX_32BIT); |
522 | setup_new_exec(bprm); | ||
522 | } | 523 | } |
523 | 524 | ||
524 | /* | 525 | /* |
diff --git a/fs/binfmt_som.c b/fs/binfmt_som.c index 2a9b5330cc5e..cc8560f6c9b0 100644 --- a/fs/binfmt_som.c +++ b/fs/binfmt_som.c | |||
@@ -227,6 +227,7 @@ load_som_binary(struct linux_binprm * bprm, struct pt_regs * regs) | |||
227 | /* OK, This is the point of no return */ | 227 | /* OK, This is the point of no return */ |
228 | current->flags &= ~PF_FORKNOEXEC; | 228 | current->flags &= ~PF_FORKNOEXEC; |
229 | current->personality = PER_HPUX; | 229 | current->personality = PER_HPUX; |
230 | setup_new_exec(bprm); | ||
230 | 231 | ||
231 | /* Set the task size for HP-UX processes such that | 232 | /* Set the task size for HP-UX processes such that |
232 | * the gateway page is outside the address space. | 233 | * the gateway page is outside the address space. |
diff --git a/fs/bio-integrity.c b/fs/bio-integrity.c index 49a34e7f7306..a16f29e888cd 100644 --- a/fs/bio-integrity.c +++ b/fs/bio-integrity.c | |||
@@ -61,7 +61,7 @@ static inline unsigned int vecs_to_idx(unsigned int nr) | |||
61 | 61 | ||
62 | static inline int use_bip_pool(unsigned int idx) | 62 | static inline int use_bip_pool(unsigned int idx) |
63 | { | 63 | { |
64 | if (idx == BIOVEC_NR_POOLS) | 64 | if (idx == BIOVEC_MAX_IDX) |
65 | return 1; | 65 | return 1; |
66 | 66 | ||
67 | return 0; | 67 | return 0; |
@@ -95,6 +95,7 @@ struct bio_integrity_payload *bio_integrity_alloc_bioset(struct bio *bio, | |||
95 | 95 | ||
96 | /* Use mempool if lower order alloc failed or max vecs were requested */ | 96 | /* Use mempool if lower order alloc failed or max vecs were requested */ |
97 | if (bip == NULL) { | 97 | if (bip == NULL) { |
98 | idx = BIOVEC_MAX_IDX; /* so we free the payload properly later */ | ||
98 | bip = mempool_alloc(bs->bio_integrity_pool, gfp_mask); | 99 | bip = mempool_alloc(bs->bio_integrity_pool, gfp_mask); |
99 | 100 | ||
100 | if (unlikely(bip == NULL)) { | 101 | if (unlikely(bip == NULL)) { |
@@ -78,7 +78,7 @@ static struct kmem_cache *bio_find_or_create_slab(unsigned int extra_size) | |||
78 | 78 | ||
79 | i = 0; | 79 | i = 0; |
80 | while (i < bio_slab_nr) { | 80 | while (i < bio_slab_nr) { |
81 | struct bio_slab *bslab = &bio_slabs[i]; | 81 | bslab = &bio_slabs[i]; |
82 | 82 | ||
83 | if (!bslab->slab && entry == -1) | 83 | if (!bslab->slab && entry == -1) |
84 | entry = i; | 84 | entry = i; |
@@ -542,13 +542,18 @@ static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page | |||
542 | 542 | ||
543 | if (page == prev->bv_page && | 543 | if (page == prev->bv_page && |
544 | offset == prev->bv_offset + prev->bv_len) { | 544 | offset == prev->bv_offset + prev->bv_len) { |
545 | unsigned int prev_bv_len = prev->bv_len; | ||
545 | prev->bv_len += len; | 546 | prev->bv_len += len; |
546 | 547 | ||
547 | if (q->merge_bvec_fn) { | 548 | if (q->merge_bvec_fn) { |
548 | struct bvec_merge_data bvm = { | 549 | struct bvec_merge_data bvm = { |
550 | /* prev_bvec is already charged in | ||
551 | bi_size, discharge it in order to | ||
552 | simulate merging updated prev_bvec | ||
553 | as new bvec. */ | ||
549 | .bi_bdev = bio->bi_bdev, | 554 | .bi_bdev = bio->bi_bdev, |
550 | .bi_sector = bio->bi_sector, | 555 | .bi_sector = bio->bi_sector, |
551 | .bi_size = bio->bi_size, | 556 | .bi_size = bio->bi_size - prev_bv_len, |
552 | .bi_rw = bio->bi_rw, | 557 | .bi_rw = bio->bi_rw, |
553 | }; | 558 | }; |
554 | 559 | ||
diff --git a/fs/block_dev.c b/fs/block_dev.c index 73d6a735b8f3..d11d0289f3d2 100644 --- a/fs/block_dev.c +++ b/fs/block_dev.c | |||
@@ -246,7 +246,8 @@ struct super_block *freeze_bdev(struct block_device *bdev) | |||
246 | if (!sb) | 246 | if (!sb) |
247 | goto out; | 247 | goto out; |
248 | if (sb->s_flags & MS_RDONLY) { | 248 | if (sb->s_flags & MS_RDONLY) { |
249 | deactivate_locked_super(sb); | 249 | sb->s_frozen = SB_FREEZE_TRANS; |
250 | up_write(&sb->s_umount); | ||
250 | mutex_unlock(&bdev->bd_fsfreeze_mutex); | 251 | mutex_unlock(&bdev->bd_fsfreeze_mutex); |
251 | return sb; | 252 | return sb; |
252 | } | 253 | } |
@@ -307,7 +308,7 @@ int thaw_bdev(struct block_device *bdev, struct super_block *sb) | |||
307 | BUG_ON(sb->s_bdev != bdev); | 308 | BUG_ON(sb->s_bdev != bdev); |
308 | down_write(&sb->s_umount); | 309 | down_write(&sb->s_umount); |
309 | if (sb->s_flags & MS_RDONLY) | 310 | if (sb->s_flags & MS_RDONLY) |
310 | goto out_deactivate; | 311 | goto out_unfrozen; |
311 | 312 | ||
312 | if (sb->s_op->unfreeze_fs) { | 313 | if (sb->s_op->unfreeze_fs) { |
313 | error = sb->s_op->unfreeze_fs(sb); | 314 | error = sb->s_op->unfreeze_fs(sb); |
@@ -321,11 +322,11 @@ int thaw_bdev(struct block_device *bdev, struct super_block *sb) | |||
321 | } | 322 | } |
322 | } | 323 | } |
323 | 324 | ||
325 | out_unfrozen: | ||
324 | sb->s_frozen = SB_UNFROZEN; | 326 | sb->s_frozen = SB_UNFROZEN; |
325 | smp_wmb(); | 327 | smp_wmb(); |
326 | wake_up(&sb->s_wait_unfrozen); | 328 | wake_up(&sb->s_wait_unfrozen); |
327 | 329 | ||
328 | out_deactivate: | ||
329 | if (sb) | 330 | if (sb) |
330 | deactivate_locked_super(sb); | 331 | deactivate_locked_super(sb); |
331 | out_unlock: | 332 | out_unlock: |
diff --git a/fs/btrfs/acl.c b/fs/btrfs/acl.c index 2e9e69987a82..6df6d6ed74fd 100644 --- a/fs/btrfs/acl.c +++ b/fs/btrfs/acl.c | |||
@@ -112,12 +112,14 @@ static int btrfs_set_acl(struct btrfs_trans_handle *trans, | |||
112 | switch (type) { | 112 | switch (type) { |
113 | case ACL_TYPE_ACCESS: | 113 | case ACL_TYPE_ACCESS: |
114 | mode = inode->i_mode; | 114 | mode = inode->i_mode; |
115 | ret = posix_acl_equiv_mode(acl, &mode); | ||
116 | if (ret < 0) | ||
117 | return ret; | ||
118 | ret = 0; | ||
119 | inode->i_mode = mode; | ||
120 | name = POSIX_ACL_XATTR_ACCESS; | 115 | name = POSIX_ACL_XATTR_ACCESS; |
116 | if (acl) { | ||
117 | ret = posix_acl_equiv_mode(acl, &mode); | ||
118 | if (ret < 0) | ||
119 | return ret; | ||
120 | inode->i_mode = mode; | ||
121 | } | ||
122 | ret = 0; | ||
121 | break; | 123 | break; |
122 | case ACL_TYPE_DEFAULT: | 124 | case ACL_TYPE_DEFAULT: |
123 | if (!S_ISDIR(inode->i_mode)) | 125 | if (!S_ISDIR(inode->i_mode)) |
@@ -242,6 +244,7 @@ int btrfs_init_acl(struct btrfs_trans_handle *trans, | |||
242 | ACL_TYPE_ACCESS); | 244 | ACL_TYPE_ACCESS); |
243 | } | 245 | } |
244 | } | 246 | } |
247 | posix_acl_release(clone); | ||
245 | } | 248 | } |
246 | failed: | 249 | failed: |
247 | posix_acl_release(acl); | 250 | posix_acl_release(acl); |
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h index 9f806dd04c27..2aa8ec6a0981 100644 --- a/fs/btrfs/ctree.h +++ b/fs/btrfs/ctree.h | |||
@@ -1161,6 +1161,7 @@ struct btrfs_root { | |||
1161 | #define BTRFS_MOUNT_SSD_SPREAD (1 << 8) | 1161 | #define BTRFS_MOUNT_SSD_SPREAD (1 << 8) |
1162 | #define BTRFS_MOUNT_NOSSD (1 << 9) | 1162 | #define BTRFS_MOUNT_NOSSD (1 << 9) |
1163 | #define BTRFS_MOUNT_DISCARD (1 << 10) | 1163 | #define BTRFS_MOUNT_DISCARD (1 << 10) |
1164 | #define BTRFS_MOUNT_FORCE_COMPRESS (1 << 11) | ||
1164 | 1165 | ||
1165 | #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt) | 1166 | #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt) |
1166 | #define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt) | 1167 | #define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt) |
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c index 009e3bd18f23..2b59201b955c 100644 --- a/fs/btrfs/disk-io.c +++ b/fs/btrfs/disk-io.c | |||
@@ -1982,7 +1982,12 @@ struct btrfs_root *open_ctree(struct super_block *sb, | |||
1982 | 1982 | ||
1983 | if (!(sb->s_flags & MS_RDONLY)) { | 1983 | if (!(sb->s_flags & MS_RDONLY)) { |
1984 | ret = btrfs_recover_relocation(tree_root); | 1984 | ret = btrfs_recover_relocation(tree_root); |
1985 | BUG_ON(ret); | 1985 | if (ret < 0) { |
1986 | printk(KERN_WARNING | ||
1987 | "btrfs: failed to recover relocation\n"); | ||
1988 | err = -EINVAL; | ||
1989 | goto fail_trans_kthread; | ||
1990 | } | ||
1986 | } | 1991 | } |
1987 | 1992 | ||
1988 | location.objectid = BTRFS_FS_TREE_OBJECTID; | 1993 | location.objectid = BTRFS_FS_TREE_OBJECTID; |
@@ -1993,6 +1998,12 @@ struct btrfs_root *open_ctree(struct super_block *sb, | |||
1993 | if (!fs_info->fs_root) | 1998 | if (!fs_info->fs_root) |
1994 | goto fail_trans_kthread; | 1999 | goto fail_trans_kthread; |
1995 | 2000 | ||
2001 | if (!(sb->s_flags & MS_RDONLY)) { | ||
2002 | down_read(&fs_info->cleanup_work_sem); | ||
2003 | btrfs_orphan_cleanup(fs_info->fs_root); | ||
2004 | up_read(&fs_info->cleanup_work_sem); | ||
2005 | } | ||
2006 | |||
1996 | return tree_root; | 2007 | return tree_root; |
1997 | 2008 | ||
1998 | fail_trans_kthread: | 2009 | fail_trans_kthread: |
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c index 56e50137d0e6..559f72489b3b 100644 --- a/fs/btrfs/extent-tree.c +++ b/fs/btrfs/extent-tree.c | |||
@@ -83,6 +83,17 @@ static int block_group_bits(struct btrfs_block_group_cache *cache, u64 bits) | |||
83 | return (cache->flags & bits) == bits; | 83 | return (cache->flags & bits) == bits; |
84 | } | 84 | } |
85 | 85 | ||
86 | void btrfs_get_block_group(struct btrfs_block_group_cache *cache) | ||
87 | { | ||
88 | atomic_inc(&cache->count); | ||
89 | } | ||
90 | |||
91 | void btrfs_put_block_group(struct btrfs_block_group_cache *cache) | ||
92 | { | ||
93 | if (atomic_dec_and_test(&cache->count)) | ||
94 | kfree(cache); | ||
95 | } | ||
96 | |||
86 | /* | 97 | /* |
87 | * this adds the block group to the fs_info rb tree for the block group | 98 | * this adds the block group to the fs_info rb tree for the block group |
88 | * cache | 99 | * cache |
@@ -156,7 +167,7 @@ block_group_cache_tree_search(struct btrfs_fs_info *info, u64 bytenr, | |||
156 | } | 167 | } |
157 | } | 168 | } |
158 | if (ret) | 169 | if (ret) |
159 | atomic_inc(&ret->count); | 170 | btrfs_get_block_group(ret); |
160 | spin_unlock(&info->block_group_cache_lock); | 171 | spin_unlock(&info->block_group_cache_lock); |
161 | 172 | ||
162 | return ret; | 173 | return ret; |
@@ -407,6 +418,8 @@ err: | |||
407 | 418 | ||
408 | put_caching_control(caching_ctl); | 419 | put_caching_control(caching_ctl); |
409 | atomic_dec(&block_group->space_info->caching_threads); | 420 | atomic_dec(&block_group->space_info->caching_threads); |
421 | btrfs_put_block_group(block_group); | ||
422 | |||
410 | return 0; | 423 | return 0; |
411 | } | 424 | } |
412 | 425 | ||
@@ -447,6 +460,7 @@ static int cache_block_group(struct btrfs_block_group_cache *cache) | |||
447 | up_write(&fs_info->extent_commit_sem); | 460 | up_write(&fs_info->extent_commit_sem); |
448 | 461 | ||
449 | atomic_inc(&cache->space_info->caching_threads); | 462 | atomic_inc(&cache->space_info->caching_threads); |
463 | btrfs_get_block_group(cache); | ||
450 | 464 | ||
451 | tsk = kthread_run(caching_kthread, cache, "btrfs-cache-%llu\n", | 465 | tsk = kthread_run(caching_kthread, cache, "btrfs-cache-%llu\n", |
452 | cache->key.objectid); | 466 | cache->key.objectid); |
@@ -486,12 +500,6 @@ struct btrfs_block_group_cache *btrfs_lookup_block_group( | |||
486 | return cache; | 500 | return cache; |
487 | } | 501 | } |
488 | 502 | ||
489 | void btrfs_put_block_group(struct btrfs_block_group_cache *cache) | ||
490 | { | ||
491 | if (atomic_dec_and_test(&cache->count)) | ||
492 | kfree(cache); | ||
493 | } | ||
494 | |||
495 | static struct btrfs_space_info *__find_space_info(struct btrfs_fs_info *info, | 503 | static struct btrfs_space_info *__find_space_info(struct btrfs_fs_info *info, |
496 | u64 flags) | 504 | u64 flags) |
497 | { | 505 | { |
@@ -2582,7 +2590,7 @@ next_block_group(struct btrfs_root *root, | |||
2582 | if (node) { | 2590 | if (node) { |
2583 | cache = rb_entry(node, struct btrfs_block_group_cache, | 2591 | cache = rb_entry(node, struct btrfs_block_group_cache, |
2584 | cache_node); | 2592 | cache_node); |
2585 | atomic_inc(&cache->count); | 2593 | btrfs_get_block_group(cache); |
2586 | } else | 2594 | } else |
2587 | cache = NULL; | 2595 | cache = NULL; |
2588 | spin_unlock(&root->fs_info->block_group_cache_lock); | 2596 | spin_unlock(&root->fs_info->block_group_cache_lock); |
@@ -4227,7 +4235,7 @@ search: | |||
4227 | u64 offset; | 4235 | u64 offset; |
4228 | int cached; | 4236 | int cached; |
4229 | 4237 | ||
4230 | atomic_inc(&block_group->count); | 4238 | btrfs_get_block_group(block_group); |
4231 | search_start = block_group->key.objectid; | 4239 | search_start = block_group->key.objectid; |
4232 | 4240 | ||
4233 | have_block_group: | 4241 | have_block_group: |
@@ -4315,7 +4323,7 @@ have_block_group: | |||
4315 | 4323 | ||
4316 | btrfs_put_block_group(block_group); | 4324 | btrfs_put_block_group(block_group); |
4317 | block_group = last_ptr->block_group; | 4325 | block_group = last_ptr->block_group; |
4318 | atomic_inc(&block_group->count); | 4326 | btrfs_get_block_group(block_group); |
4319 | spin_unlock(&last_ptr->lock); | 4327 | spin_unlock(&last_ptr->lock); |
4320 | spin_unlock(&last_ptr->refill_lock); | 4328 | spin_unlock(&last_ptr->refill_lock); |
4321 | 4329 | ||
@@ -5394,10 +5402,6 @@ static noinline int walk_down_tree(struct btrfs_trans_handle *trans, | |||
5394 | int ret; | 5402 | int ret; |
5395 | 5403 | ||
5396 | while (level >= 0) { | 5404 | while (level >= 0) { |
5397 | if (path->slots[level] >= | ||
5398 | btrfs_header_nritems(path->nodes[level])) | ||
5399 | break; | ||
5400 | |||
5401 | ret = walk_down_proc(trans, root, path, wc, lookup_info); | 5405 | ret = walk_down_proc(trans, root, path, wc, lookup_info); |
5402 | if (ret > 0) | 5406 | if (ret > 0) |
5403 | break; | 5407 | break; |
@@ -5405,6 +5409,10 @@ static noinline int walk_down_tree(struct btrfs_trans_handle *trans, | |||
5405 | if (level == 0) | 5409 | if (level == 0) |
5406 | break; | 5410 | break; |
5407 | 5411 | ||
5412 | if (path->slots[level] >= | ||
5413 | btrfs_header_nritems(path->nodes[level])) | ||
5414 | break; | ||
5415 | |||
5408 | ret = do_walk_down(trans, root, path, wc, &lookup_info); | 5416 | ret = do_walk_down(trans, root, path, wc, &lookup_info); |
5409 | if (ret > 0) { | 5417 | if (ret > 0) { |
5410 | path->slots[level]++; | 5418 | path->slots[level]++; |
@@ -7395,9 +7403,7 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info) | |||
7395 | wait_block_group_cache_done(block_group); | 7403 | wait_block_group_cache_done(block_group); |
7396 | 7404 | ||
7397 | btrfs_remove_free_space_cache(block_group); | 7405 | btrfs_remove_free_space_cache(block_group); |
7398 | 7406 | btrfs_put_block_group(block_group); | |
7399 | WARN_ON(atomic_read(&block_group->count) != 1); | ||
7400 | kfree(block_group); | ||
7401 | 7407 | ||
7402 | spin_lock(&info->block_group_cache_lock); | 7408 | spin_lock(&info->block_group_cache_lock); |
7403 | } | 7409 | } |
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 96577e8bf9fd..b177ed319612 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c | |||
@@ -3165,10 +3165,9 @@ struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree, | |||
3165 | spin_unlock(&tree->buffer_lock); | 3165 | spin_unlock(&tree->buffer_lock); |
3166 | goto free_eb; | 3166 | goto free_eb; |
3167 | } | 3167 | } |
3168 | spin_unlock(&tree->buffer_lock); | ||
3169 | |||
3170 | /* add one reference for the tree */ | 3168 | /* add one reference for the tree */ |
3171 | atomic_inc(&eb->refs); | 3169 | atomic_inc(&eb->refs); |
3170 | spin_unlock(&tree->buffer_lock); | ||
3172 | return eb; | 3171 | return eb; |
3173 | 3172 | ||
3174 | free_eb: | 3173 | free_eb: |
diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c index 46bea0f4dc7b..428fcac45f90 100644 --- a/fs/btrfs/extent_map.c +++ b/fs/btrfs/extent_map.c | |||
@@ -155,20 +155,6 @@ static struct rb_node *__tree_search(struct rb_root *root, u64 offset, | |||
155 | return NULL; | 155 | return NULL; |
156 | } | 156 | } |
157 | 157 | ||
158 | /* | ||
159 | * look for an offset in the tree, and if it can't be found, return | ||
160 | * the first offset we can find smaller than 'offset'. | ||
161 | */ | ||
162 | static inline struct rb_node *tree_search(struct rb_root *root, u64 offset) | ||
163 | { | ||
164 | struct rb_node *prev; | ||
165 | struct rb_node *ret; | ||
166 | ret = __tree_search(root, offset, &prev, NULL); | ||
167 | if (!ret) | ||
168 | return prev; | ||
169 | return ret; | ||
170 | } | ||
171 | |||
172 | /* check to see if two extent_map structs are adjacent and safe to merge */ | 158 | /* check to see if two extent_map structs are adjacent and safe to merge */ |
173 | static int mergable_maps(struct extent_map *prev, struct extent_map *next) | 159 | static int mergable_maps(struct extent_map *prev, struct extent_map *next) |
174 | { | 160 | { |
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c index feaa13b105d9..6ed434ac037f 100644 --- a/fs/btrfs/file.c +++ b/fs/btrfs/file.c | |||
@@ -506,7 +506,8 @@ next_slot: | |||
506 | } | 506 | } |
507 | 507 | ||
508 | static int extent_mergeable(struct extent_buffer *leaf, int slot, | 508 | static int extent_mergeable(struct extent_buffer *leaf, int slot, |
509 | u64 objectid, u64 bytenr, u64 *start, u64 *end) | 509 | u64 objectid, u64 bytenr, u64 orig_offset, |
510 | u64 *start, u64 *end) | ||
510 | { | 511 | { |
511 | struct btrfs_file_extent_item *fi; | 512 | struct btrfs_file_extent_item *fi; |
512 | struct btrfs_key key; | 513 | struct btrfs_key key; |
@@ -522,6 +523,7 @@ static int extent_mergeable(struct extent_buffer *leaf, int slot, | |||
522 | fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); | 523 | fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); |
523 | if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG || | 524 | if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG || |
524 | btrfs_file_extent_disk_bytenr(leaf, fi) != bytenr || | 525 | btrfs_file_extent_disk_bytenr(leaf, fi) != bytenr || |
526 | btrfs_file_extent_offset(leaf, fi) != key.offset - orig_offset || | ||
525 | btrfs_file_extent_compression(leaf, fi) || | 527 | btrfs_file_extent_compression(leaf, fi) || |
526 | btrfs_file_extent_encryption(leaf, fi) || | 528 | btrfs_file_extent_encryption(leaf, fi) || |
527 | btrfs_file_extent_other_encoding(leaf, fi)) | 529 | btrfs_file_extent_other_encoding(leaf, fi)) |
@@ -561,6 +563,7 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, | |||
561 | u64 split; | 563 | u64 split; |
562 | int del_nr = 0; | 564 | int del_nr = 0; |
563 | int del_slot = 0; | 565 | int del_slot = 0; |
566 | int recow; | ||
564 | int ret; | 567 | int ret; |
565 | 568 | ||
566 | btrfs_drop_extent_cache(inode, start, end - 1, 0); | 569 | btrfs_drop_extent_cache(inode, start, end - 1, 0); |
@@ -568,6 +571,7 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, | |||
568 | path = btrfs_alloc_path(); | 571 | path = btrfs_alloc_path(); |
569 | BUG_ON(!path); | 572 | BUG_ON(!path); |
570 | again: | 573 | again: |
574 | recow = 0; | ||
571 | split = start; | 575 | split = start; |
572 | key.objectid = inode->i_ino; | 576 | key.objectid = inode->i_ino; |
573 | key.type = BTRFS_EXTENT_DATA_KEY; | 577 | key.type = BTRFS_EXTENT_DATA_KEY; |
@@ -591,12 +595,60 @@ again: | |||
591 | bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); | 595 | bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); |
592 | num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi); | 596 | num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi); |
593 | orig_offset = key.offset - btrfs_file_extent_offset(leaf, fi); | 597 | orig_offset = key.offset - btrfs_file_extent_offset(leaf, fi); |
598 | memcpy(&new_key, &key, sizeof(new_key)); | ||
599 | |||
600 | if (start == key.offset && end < extent_end) { | ||
601 | other_start = 0; | ||
602 | other_end = start; | ||
603 | if (extent_mergeable(leaf, path->slots[0] - 1, | ||
604 | inode->i_ino, bytenr, orig_offset, | ||
605 | &other_start, &other_end)) { | ||
606 | new_key.offset = end; | ||
607 | btrfs_set_item_key_safe(trans, root, path, &new_key); | ||
608 | fi = btrfs_item_ptr(leaf, path->slots[0], | ||
609 | struct btrfs_file_extent_item); | ||
610 | btrfs_set_file_extent_num_bytes(leaf, fi, | ||
611 | extent_end - end); | ||
612 | btrfs_set_file_extent_offset(leaf, fi, | ||
613 | end - orig_offset); | ||
614 | fi = btrfs_item_ptr(leaf, path->slots[0] - 1, | ||
615 | struct btrfs_file_extent_item); | ||
616 | btrfs_set_file_extent_num_bytes(leaf, fi, | ||
617 | end - other_start); | ||
618 | btrfs_mark_buffer_dirty(leaf); | ||
619 | goto out; | ||
620 | } | ||
621 | } | ||
622 | |||
623 | if (start > key.offset && end == extent_end) { | ||
624 | other_start = end; | ||
625 | other_end = 0; | ||
626 | if (extent_mergeable(leaf, path->slots[0] + 1, | ||
627 | inode->i_ino, bytenr, orig_offset, | ||
628 | &other_start, &other_end)) { | ||
629 | fi = btrfs_item_ptr(leaf, path->slots[0], | ||
630 | struct btrfs_file_extent_item); | ||
631 | btrfs_set_file_extent_num_bytes(leaf, fi, | ||
632 | start - key.offset); | ||
633 | path->slots[0]++; | ||
634 | new_key.offset = start; | ||
635 | btrfs_set_item_key_safe(trans, root, path, &new_key); | ||
636 | |||
637 | fi = btrfs_item_ptr(leaf, path->slots[0], | ||
638 | struct btrfs_file_extent_item); | ||
639 | btrfs_set_file_extent_num_bytes(leaf, fi, | ||
640 | other_end - start); | ||
641 | btrfs_set_file_extent_offset(leaf, fi, | ||
642 | start - orig_offset); | ||
643 | btrfs_mark_buffer_dirty(leaf); | ||
644 | goto out; | ||
645 | } | ||
646 | } | ||
594 | 647 | ||
595 | while (start > key.offset || end < extent_end) { | 648 | while (start > key.offset || end < extent_end) { |
596 | if (key.offset == start) | 649 | if (key.offset == start) |
597 | split = end; | 650 | split = end; |
598 | 651 | ||
599 | memcpy(&new_key, &key, sizeof(new_key)); | ||
600 | new_key.offset = split; | 652 | new_key.offset = split; |
601 | ret = btrfs_duplicate_item(trans, root, path, &new_key); | 653 | ret = btrfs_duplicate_item(trans, root, path, &new_key); |
602 | if (ret == -EAGAIN) { | 654 | if (ret == -EAGAIN) { |
@@ -631,15 +683,18 @@ again: | |||
631 | path->slots[0]--; | 683 | path->slots[0]--; |
632 | extent_end = end; | 684 | extent_end = end; |
633 | } | 685 | } |
686 | recow = 1; | ||
634 | } | 687 | } |
635 | 688 | ||
636 | fi = btrfs_item_ptr(leaf, path->slots[0], | ||
637 | struct btrfs_file_extent_item); | ||
638 | |||
639 | other_start = end; | 689 | other_start = end; |
640 | other_end = 0; | 690 | other_end = 0; |
641 | if (extent_mergeable(leaf, path->slots[0] + 1, inode->i_ino, | 691 | if (extent_mergeable(leaf, path->slots[0] + 1, |
642 | bytenr, &other_start, &other_end)) { | 692 | inode->i_ino, bytenr, orig_offset, |
693 | &other_start, &other_end)) { | ||
694 | if (recow) { | ||
695 | btrfs_release_path(root, path); | ||
696 | goto again; | ||
697 | } | ||
643 | extent_end = other_end; | 698 | extent_end = other_end; |
644 | del_slot = path->slots[0] + 1; | 699 | del_slot = path->slots[0] + 1; |
645 | del_nr++; | 700 | del_nr++; |
@@ -650,8 +705,13 @@ again: | |||
650 | } | 705 | } |
651 | other_start = 0; | 706 | other_start = 0; |
652 | other_end = start; | 707 | other_end = start; |
653 | if (extent_mergeable(leaf, path->slots[0] - 1, inode->i_ino, | 708 | if (extent_mergeable(leaf, path->slots[0] - 1, |
654 | bytenr, &other_start, &other_end)) { | 709 | inode->i_ino, bytenr, orig_offset, |
710 | &other_start, &other_end)) { | ||
711 | if (recow) { | ||
712 | btrfs_release_path(root, path); | ||
713 | goto again; | ||
714 | } | ||
655 | key.offset = other_start; | 715 | key.offset = other_start; |
656 | del_slot = path->slots[0]; | 716 | del_slot = path->slots[0]; |
657 | del_nr++; | 717 | del_nr++; |
@@ -661,21 +721,23 @@ again: | |||
661 | BUG_ON(ret); | 721 | BUG_ON(ret); |
662 | } | 722 | } |
663 | if (del_nr == 0) { | 723 | if (del_nr == 0) { |
724 | fi = btrfs_item_ptr(leaf, path->slots[0], | ||
725 | struct btrfs_file_extent_item); | ||
664 | btrfs_set_file_extent_type(leaf, fi, | 726 | btrfs_set_file_extent_type(leaf, fi, |
665 | BTRFS_FILE_EXTENT_REG); | 727 | BTRFS_FILE_EXTENT_REG); |
666 | btrfs_mark_buffer_dirty(leaf); | 728 | btrfs_mark_buffer_dirty(leaf); |
667 | goto out; | 729 | } else { |
668 | } | 730 | fi = btrfs_item_ptr(leaf, del_slot - 1, |
669 | 731 | struct btrfs_file_extent_item); | |
670 | fi = btrfs_item_ptr(leaf, del_slot - 1, | 732 | btrfs_set_file_extent_type(leaf, fi, |
671 | struct btrfs_file_extent_item); | 733 | BTRFS_FILE_EXTENT_REG); |
672 | btrfs_set_file_extent_type(leaf, fi, BTRFS_FILE_EXTENT_REG); | 734 | btrfs_set_file_extent_num_bytes(leaf, fi, |
673 | btrfs_set_file_extent_num_bytes(leaf, fi, | 735 | extent_end - key.offset); |
674 | extent_end - key.offset); | 736 | btrfs_mark_buffer_dirty(leaf); |
675 | btrfs_mark_buffer_dirty(leaf); | ||
676 | 737 | ||
677 | ret = btrfs_del_items(trans, root, path, del_slot, del_nr); | 738 | ret = btrfs_del_items(trans, root, path, del_slot, del_nr); |
678 | BUG_ON(ret); | 739 | BUG_ON(ret); |
740 | } | ||
679 | out: | 741 | out: |
680 | btrfs_free_path(path); | 742 | btrfs_free_path(path); |
681 | return 0; | 743 | return 0; |
@@ -1073,7 +1135,7 @@ int btrfs_sync_file(struct file *file, struct dentry *dentry, int datasync) | |||
1073 | } | 1135 | } |
1074 | mutex_lock(&dentry->d_inode->i_mutex); | 1136 | mutex_lock(&dentry->d_inode->i_mutex); |
1075 | out: | 1137 | out: |
1076 | return ret > 0 ? EIO : ret; | 1138 | return ret > 0 ? -EIO : ret; |
1077 | } | 1139 | } |
1078 | 1140 | ||
1079 | static const struct vm_operations_struct btrfs_file_vm_ops = { | 1141 | static const struct vm_operations_struct btrfs_file_vm_ops = { |
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 5440bab23635..4deb280f8969 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c | |||
@@ -483,7 +483,8 @@ again: | |||
483 | nr_pages_ret = 0; | 483 | nr_pages_ret = 0; |
484 | 484 | ||
485 | /* flag the file so we don't compress in the future */ | 485 | /* flag the file so we don't compress in the future */ |
486 | BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS; | 486 | if (!btrfs_test_opt(root, FORCE_COMPRESS)) |
487 | BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS; | ||
487 | } | 488 | } |
488 | if (will_compress) { | 489 | if (will_compress) { |
489 | *num_added += 1; | 490 | *num_added += 1; |
@@ -1680,24 +1681,6 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans, | |||
1680 | * before we start the transaction. It limits the amount of btree | 1681 | * before we start the transaction. It limits the amount of btree |
1681 | * reads required while inside the transaction. | 1682 | * reads required while inside the transaction. |
1682 | */ | 1683 | */ |
1683 | static noinline void reada_csum(struct btrfs_root *root, | ||
1684 | struct btrfs_path *path, | ||
1685 | struct btrfs_ordered_extent *ordered_extent) | ||
1686 | { | ||
1687 | struct btrfs_ordered_sum *sum; | ||
1688 | u64 bytenr; | ||
1689 | |||
1690 | sum = list_entry(ordered_extent->list.next, struct btrfs_ordered_sum, | ||
1691 | list); | ||
1692 | bytenr = sum->sums[0].bytenr; | ||
1693 | |||
1694 | /* | ||
1695 | * we don't care about the results, the point of this search is | ||
1696 | * just to get the btree leaves into ram | ||
1697 | */ | ||
1698 | btrfs_lookup_csum(NULL, root->fs_info->csum_root, path, bytenr, 0); | ||
1699 | } | ||
1700 | |||
1701 | /* as ordered data IO finishes, this gets called so we can finish | 1684 | /* as ordered data IO finishes, this gets called so we can finish |
1702 | * an ordered extent if the range of bytes in the file it covers are | 1685 | * an ordered extent if the range of bytes in the file it covers are |
1703 | * fully written. | 1686 | * fully written. |
@@ -1708,7 +1691,6 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end) | |||
1708 | struct btrfs_trans_handle *trans; | 1691 | struct btrfs_trans_handle *trans; |
1709 | struct btrfs_ordered_extent *ordered_extent = NULL; | 1692 | struct btrfs_ordered_extent *ordered_extent = NULL; |
1710 | struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; | 1693 | struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; |
1711 | struct btrfs_path *path; | ||
1712 | int compressed = 0; | 1694 | int compressed = 0; |
1713 | int ret; | 1695 | int ret; |
1714 | 1696 | ||
@@ -1716,32 +1698,9 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end) | |||
1716 | if (!ret) | 1698 | if (!ret) |
1717 | return 0; | 1699 | return 0; |
1718 | 1700 | ||
1719 | /* | 1701 | ordered_extent = btrfs_lookup_ordered_extent(inode, start); |
1720 | * before we join the transaction, try to do some of our IO. | ||
1721 | * This will limit the amount of IO that we have to do with | ||
1722 | * the transaction running. We're unlikely to need to do any | ||
1723 | * IO if the file extents are new, the disk_i_size checks | ||
1724 | * covers the most common case. | ||
1725 | */ | ||
1726 | if (start < BTRFS_I(inode)->disk_i_size) { | ||
1727 | path = btrfs_alloc_path(); | ||
1728 | if (path) { | ||
1729 | ret = btrfs_lookup_file_extent(NULL, root, path, | ||
1730 | inode->i_ino, | ||
1731 | start, 0); | ||
1732 | ordered_extent = btrfs_lookup_ordered_extent(inode, | ||
1733 | start); | ||
1734 | if (!list_empty(&ordered_extent->list)) { | ||
1735 | btrfs_release_path(root, path); | ||
1736 | reada_csum(root, path, ordered_extent); | ||
1737 | } | ||
1738 | btrfs_free_path(path); | ||
1739 | } | ||
1740 | } | ||
1741 | |||
1742 | if (!ordered_extent) | ||
1743 | ordered_extent = btrfs_lookup_ordered_extent(inode, start); | ||
1744 | BUG_ON(!ordered_extent); | 1702 | BUG_ON(!ordered_extent); |
1703 | |||
1745 | if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) { | 1704 | if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) { |
1746 | BUG_ON(!list_empty(&ordered_extent->list)); | 1705 | BUG_ON(!list_empty(&ordered_extent->list)); |
1747 | ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent); | 1706 | ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent); |
@@ -3995,7 +3954,11 @@ skip: | |||
3995 | 3954 | ||
3996 | /* Reached end of directory/root. Bump pos past the last item. */ | 3955 | /* Reached end of directory/root. Bump pos past the last item. */ |
3997 | if (key_type == BTRFS_DIR_INDEX_KEY) | 3956 | if (key_type == BTRFS_DIR_INDEX_KEY) |
3998 | filp->f_pos = INT_LIMIT(off_t); | 3957 | /* |
3958 | * 32-bit glibc will use getdents64, but then strtol - | ||
3959 | * so the last number we can serve is this. | ||
3960 | */ | ||
3961 | filp->f_pos = 0x7fffffff; | ||
3999 | else | 3962 | else |
4000 | filp->f_pos++; | 3963 | filp->f_pos++; |
4001 | nopos: | 3964 | nopos: |
@@ -5789,7 +5752,7 @@ out_fail: | |||
5789 | } | 5752 | } |
5790 | 5753 | ||
5791 | static int prealloc_file_range(struct inode *inode, u64 start, u64 end, | 5754 | static int prealloc_file_range(struct inode *inode, u64 start, u64 end, |
5792 | u64 alloc_hint, int mode) | 5755 | u64 alloc_hint, int mode, loff_t actual_len) |
5793 | { | 5756 | { |
5794 | struct btrfs_trans_handle *trans; | 5757 | struct btrfs_trans_handle *trans; |
5795 | struct btrfs_root *root = BTRFS_I(inode)->root; | 5758 | struct btrfs_root *root = BTRFS_I(inode)->root; |
@@ -5798,6 +5761,7 @@ static int prealloc_file_range(struct inode *inode, u64 start, u64 end, | |||
5798 | u64 cur_offset = start; | 5761 | u64 cur_offset = start; |
5799 | u64 num_bytes = end - start; | 5762 | u64 num_bytes = end - start; |
5800 | int ret = 0; | 5763 | int ret = 0; |
5764 | u64 i_size; | ||
5801 | 5765 | ||
5802 | while (num_bytes > 0) { | 5766 | while (num_bytes > 0) { |
5803 | alloc_size = min(num_bytes, root->fs_info->max_extent); | 5767 | alloc_size = min(num_bytes, root->fs_info->max_extent); |
@@ -5835,9 +5799,15 @@ static int prealloc_file_range(struct inode *inode, u64 start, u64 end, | |||
5835 | inode->i_ctime = CURRENT_TIME; | 5799 | inode->i_ctime = CURRENT_TIME; |
5836 | BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC; | 5800 | BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC; |
5837 | if (!(mode & FALLOC_FL_KEEP_SIZE) && | 5801 | if (!(mode & FALLOC_FL_KEEP_SIZE) && |
5838 | cur_offset > inode->i_size) { | 5802 | (actual_len > inode->i_size) && |
5839 | i_size_write(inode, cur_offset); | 5803 | (cur_offset > inode->i_size)) { |
5840 | btrfs_ordered_update_i_size(inode, cur_offset, NULL); | 5804 | |
5805 | if (cur_offset > actual_len) | ||
5806 | i_size = actual_len; | ||
5807 | else | ||
5808 | i_size = cur_offset; | ||
5809 | i_size_write(inode, i_size); | ||
5810 | btrfs_ordered_update_i_size(inode, i_size, NULL); | ||
5841 | } | 5811 | } |
5842 | 5812 | ||
5843 | ret = btrfs_update_inode(trans, root, inode); | 5813 | ret = btrfs_update_inode(trans, root, inode); |
@@ -5930,7 +5900,7 @@ static long btrfs_fallocate(struct inode *inode, int mode, | |||
5930 | !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) { | 5900 | !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) { |
5931 | ret = prealloc_file_range(inode, | 5901 | ret = prealloc_file_range(inode, |
5932 | cur_offset, last_byte, | 5902 | cur_offset, last_byte, |
5933 | alloc_hint, mode); | 5903 | alloc_hint, mode, offset+len); |
5934 | if (ret < 0) { | 5904 | if (ret < 0) { |
5935 | free_extent_map(em); | 5905 | free_extent_map(em); |
5936 | break; | 5906 | break; |
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c index b10a49d4bc6a..5c2a9e78a949 100644 --- a/fs/btrfs/ordered-data.c +++ b/fs/btrfs/ordered-data.c | |||
@@ -626,6 +626,8 @@ int btrfs_ordered_update_i_size(struct inode *inode, u64 offset, | |||
626 | 626 | ||
627 | if (ordered) | 627 | if (ordered) |
628 | offset = entry_end(ordered); | 628 | offset = entry_end(ordered); |
629 | else | ||
630 | offset = ALIGN(offset, BTRFS_I(inode)->root->sectorsize); | ||
629 | 631 | ||
630 | mutex_lock(&tree->mutex); | 632 | mutex_lock(&tree->mutex); |
631 | disk_i_size = BTRFS_I(inode)->disk_i_size; | 633 | disk_i_size = BTRFS_I(inode)->disk_i_size; |
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c index a9728680eca8..ab7ab5318745 100644 --- a/fs/btrfs/relocation.c +++ b/fs/btrfs/relocation.c | |||
@@ -3281,8 +3281,10 @@ static noinline_for_stack int relocate_block_group(struct reloc_control *rc) | |||
3281 | return -ENOMEM; | 3281 | return -ENOMEM; |
3282 | 3282 | ||
3283 | path = btrfs_alloc_path(); | 3283 | path = btrfs_alloc_path(); |
3284 | if (!path) | 3284 | if (!path) { |
3285 | kfree(cluster); | ||
3285 | return -ENOMEM; | 3286 | return -ENOMEM; |
3287 | } | ||
3286 | 3288 | ||
3287 | rc->extents_found = 0; | 3289 | rc->extents_found = 0; |
3288 | rc->extents_skipped = 0; | 3290 | rc->extents_skipped = 0; |
@@ -3762,7 +3764,8 @@ out: | |||
3762 | BTRFS_DATA_RELOC_TREE_OBJECTID); | 3764 | BTRFS_DATA_RELOC_TREE_OBJECTID); |
3763 | if (IS_ERR(fs_root)) | 3765 | if (IS_ERR(fs_root)) |
3764 | err = PTR_ERR(fs_root); | 3766 | err = PTR_ERR(fs_root); |
3765 | btrfs_orphan_cleanup(fs_root); | 3767 | else |
3768 | btrfs_orphan_cleanup(fs_root); | ||
3766 | } | 3769 | } |
3767 | return err; | 3770 | return err; |
3768 | } | 3771 | } |
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c index 3f9b45704fcd..8a1ea6e64575 100644 --- a/fs/btrfs/super.c +++ b/fs/btrfs/super.c | |||
@@ -66,7 +66,8 @@ enum { | |||
66 | Opt_degraded, Opt_subvol, Opt_device, Opt_nodatasum, Opt_nodatacow, | 66 | Opt_degraded, Opt_subvol, Opt_device, Opt_nodatasum, Opt_nodatacow, |
67 | Opt_max_extent, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, | 67 | Opt_max_extent, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, |
68 | Opt_ssd, Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, | 68 | Opt_ssd, Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, |
69 | Opt_compress, Opt_notreelog, Opt_ratio, Opt_flushoncommit, | 69 | Opt_compress, Opt_compress_force, Opt_notreelog, Opt_ratio, |
70 | Opt_flushoncommit, | ||
70 | Opt_discard, Opt_err, | 71 | Opt_discard, Opt_err, |
71 | }; | 72 | }; |
72 | 73 | ||
@@ -82,6 +83,7 @@ static match_table_t tokens = { | |||
82 | {Opt_alloc_start, "alloc_start=%s"}, | 83 | {Opt_alloc_start, "alloc_start=%s"}, |
83 | {Opt_thread_pool, "thread_pool=%d"}, | 84 | {Opt_thread_pool, "thread_pool=%d"}, |
84 | {Opt_compress, "compress"}, | 85 | {Opt_compress, "compress"}, |
86 | {Opt_compress_force, "compress-force"}, | ||
85 | {Opt_ssd, "ssd"}, | 87 | {Opt_ssd, "ssd"}, |
86 | {Opt_ssd_spread, "ssd_spread"}, | 88 | {Opt_ssd_spread, "ssd_spread"}, |
87 | {Opt_nossd, "nossd"}, | 89 | {Opt_nossd, "nossd"}, |
@@ -173,6 +175,11 @@ int btrfs_parse_options(struct btrfs_root *root, char *options) | |||
173 | printk(KERN_INFO "btrfs: use compression\n"); | 175 | printk(KERN_INFO "btrfs: use compression\n"); |
174 | btrfs_set_opt(info->mount_opt, COMPRESS); | 176 | btrfs_set_opt(info->mount_opt, COMPRESS); |
175 | break; | 177 | break; |
178 | case Opt_compress_force: | ||
179 | printk(KERN_INFO "btrfs: forcing compression\n"); | ||
180 | btrfs_set_opt(info->mount_opt, FORCE_COMPRESS); | ||
181 | btrfs_set_opt(info->mount_opt, COMPRESS); | ||
182 | break; | ||
176 | case Opt_ssd: | 183 | case Opt_ssd: |
177 | printk(KERN_INFO "btrfs: use ssd allocation scheme\n"); | 184 | printk(KERN_INFO "btrfs: use ssd allocation scheme\n"); |
178 | btrfs_set_opt(info->mount_opt, SSD); | 185 | btrfs_set_opt(info->mount_opt, SSD); |
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c index 198cff28766d..41ecbb2347f2 100644 --- a/fs/btrfs/volumes.c +++ b/fs/btrfs/volumes.c | |||
@@ -1135,7 +1135,7 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path) | |||
1135 | root->fs_info->avail_metadata_alloc_bits; | 1135 | root->fs_info->avail_metadata_alloc_bits; |
1136 | 1136 | ||
1137 | if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) && | 1137 | if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) && |
1138 | root->fs_info->fs_devices->rw_devices <= 4) { | 1138 | root->fs_info->fs_devices->num_devices <= 4) { |
1139 | printk(KERN_ERR "btrfs: unable to go below four devices " | 1139 | printk(KERN_ERR "btrfs: unable to go below four devices " |
1140 | "on raid10\n"); | 1140 | "on raid10\n"); |
1141 | ret = -EINVAL; | 1141 | ret = -EINVAL; |
@@ -1143,7 +1143,7 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path) | |||
1143 | } | 1143 | } |
1144 | 1144 | ||
1145 | if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) && | 1145 | if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) && |
1146 | root->fs_info->fs_devices->rw_devices <= 2) { | 1146 | root->fs_info->fs_devices->num_devices <= 2) { |
1147 | printk(KERN_ERR "btrfs: unable to go below two " | 1147 | printk(KERN_ERR "btrfs: unable to go below two " |
1148 | "devices on raid1\n"); | 1148 | "devices on raid1\n"); |
1149 | ret = -EINVAL; | 1149 | ret = -EINVAL; |
@@ -1434,8 +1434,8 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path) | |||
1434 | return -EINVAL; | 1434 | return -EINVAL; |
1435 | 1435 | ||
1436 | bdev = open_bdev_exclusive(device_path, 0, root->fs_info->bdev_holder); | 1436 | bdev = open_bdev_exclusive(device_path, 0, root->fs_info->bdev_holder); |
1437 | if (!bdev) | 1437 | if (IS_ERR(bdev)) |
1438 | return -EIO; | 1438 | return PTR_ERR(bdev); |
1439 | 1439 | ||
1440 | if (root->fs_info->fs_devices->seeding) { | 1440 | if (root->fs_info->fs_devices->seeding) { |
1441 | seeding_dev = 1; | 1441 | seeding_dev = 1; |
@@ -2538,6 +2538,11 @@ int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset) | |||
2538 | if (!em) | 2538 | if (!em) |
2539 | return 1; | 2539 | return 1; |
2540 | 2540 | ||
2541 | if (btrfs_test_opt(root, DEGRADED)) { | ||
2542 | free_extent_map(em); | ||
2543 | return 0; | ||
2544 | } | ||
2545 | |||
2541 | map = (struct map_lookup *)em->bdev; | 2546 | map = (struct map_lookup *)em->bdev; |
2542 | for (i = 0; i < map->num_stripes; i++) { | 2547 | for (i = 0; i < map->num_stripes; i++) { |
2543 | if (!map->stripes[i].dev->writeable) { | 2548 | if (!map->stripes[i].dev->writeable) { |
@@ -2649,8 +2654,10 @@ again: | |||
2649 | em = lookup_extent_mapping(em_tree, logical, *length); | 2654 | em = lookup_extent_mapping(em_tree, logical, *length); |
2650 | read_unlock(&em_tree->lock); | 2655 | read_unlock(&em_tree->lock); |
2651 | 2656 | ||
2652 | if (!em && unplug_page) | 2657 | if (!em && unplug_page) { |
2658 | kfree(multi); | ||
2653 | return 0; | 2659 | return 0; |
2660 | } | ||
2654 | 2661 | ||
2655 | if (!em) { | 2662 | if (!em) { |
2656 | printk(KERN_CRIT "unable to find logical %llu len %llu\n", | 2663 | printk(KERN_CRIT "unable to find logical %llu len %llu\n", |
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c index 14ac4806e291..eeb4986ea7db 100644 --- a/fs/cachefiles/namei.c +++ b/fs/cachefiles/namei.c | |||
@@ -348,7 +348,17 @@ int cachefiles_delete_object(struct cachefiles_cache *cache, | |||
348 | dir = dget_parent(object->dentry); | 348 | dir = dget_parent(object->dentry); |
349 | 349 | ||
350 | mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); | 350 | mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); |
351 | ret = cachefiles_bury_object(cache, dir, object->dentry); | 351 | |
352 | /* we need to check that our parent is _still_ our parent - it may have | ||
353 | * been renamed */ | ||
354 | if (dir == object->dentry->d_parent) { | ||
355 | ret = cachefiles_bury_object(cache, dir, object->dentry); | ||
356 | } else { | ||
357 | /* it got moved, presumably by cachefilesd culling it, so it's | ||
358 | * no longer in the key path and we can ignore it */ | ||
359 | mutex_unlock(&dir->d_inode->i_mutex); | ||
360 | ret = 0; | ||
361 | } | ||
352 | 362 | ||
353 | dput(dir); | 363 | dput(dir); |
354 | _leave(" = %d", ret); | 364 | _leave(" = %d", ret); |
diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES index 7b2600b380d7..49503d2edc7e 100644 --- a/fs/cifs/CHANGES +++ b/fs/cifs/CHANGES | |||
@@ -1,3 +1,7 @@ | |||
1 | Version 1.62 | ||
2 | ------------ | ||
3 | Add sockopt=TCP_NODELAY mount option. | ||
4 | |||
1 | Version 1.61 | 5 | Version 1.61 |
2 | ------------ | 6 | ------------ |
3 | Fix append problem to Samba servers (files opened with O_APPEND could | 7 | Fix append problem to Samba servers (files opened with O_APPEND could |
diff --git a/fs/cifs/cifs_dfs_ref.c b/fs/cifs/cifs_dfs_ref.c index fea9e898c4ba..b44ce0a0711c 100644 --- a/fs/cifs/cifs_dfs_ref.c +++ b/fs/cifs/cifs_dfs_ref.c | |||
@@ -269,7 +269,7 @@ static int add_mount_helper(struct vfsmount *newmnt, struct nameidata *nd, | |||
269 | int err; | 269 | int err; |
270 | 270 | ||
271 | mntget(newmnt); | 271 | mntget(newmnt); |
272 | err = do_add_mount(newmnt, &nd->path, nd->path.mnt->mnt_flags, mntlist); | 272 | err = do_add_mount(newmnt, &nd->path, nd->path.mnt->mnt_flags | MNT_SHRINKABLE, mntlist); |
273 | switch (err) { | 273 | switch (err) { |
274 | case 0: | 274 | case 0: |
275 | path_put(&nd->path); | 275 | path_put(&nd->path); |
@@ -371,7 +371,6 @@ cifs_dfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd) | |||
371 | if (IS_ERR(mnt)) | 371 | if (IS_ERR(mnt)) |
372 | goto out_err; | 372 | goto out_err; |
373 | 373 | ||
374 | nd->path.mnt->mnt_flags |= MNT_SHRINKABLE; | ||
375 | rc = add_mount_helper(mnt, nd, &cifs_dfs_automount_list); | 374 | rc = add_mount_helper(mnt, nd, &cifs_dfs_automount_list); |
376 | 375 | ||
377 | out: | 376 | out: |
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h index ac2b24c192f8..78c1b86d55f6 100644 --- a/fs/cifs/cifsfs.h +++ b/fs/cifs/cifsfs.h | |||
@@ -113,5 +113,5 @@ extern long cifs_ioctl(struct file *filep, unsigned int cmd, unsigned long arg); | |||
113 | extern const struct export_operations cifs_export_ops; | 113 | extern const struct export_operations cifs_export_ops; |
114 | #endif /* EXPERIMENTAL */ | 114 | #endif /* EXPERIMENTAL */ |
115 | 115 | ||
116 | #define CIFS_VERSION "1.61" | 116 | #define CIFS_VERSION "1.62" |
117 | #endif /* _CIFSFS_H */ | 117 | #endif /* _CIFSFS_H */ |
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h index 4b35f7ec0583..ed751bb657db 100644 --- a/fs/cifs/cifsglob.h +++ b/fs/cifs/cifsglob.h | |||
@@ -149,6 +149,7 @@ struct TCP_Server_Info { | |||
149 | bool svlocal:1; /* local server or remote */ | 149 | bool svlocal:1; /* local server or remote */ |
150 | bool noblocksnd; /* use blocking sendmsg */ | 150 | bool noblocksnd; /* use blocking sendmsg */ |
151 | bool noautotune; /* do not autotune send buf sizes */ | 151 | bool noautotune; /* do not autotune send buf sizes */ |
152 | bool tcp_nodelay; | ||
152 | atomic_t inFlight; /* number of requests on the wire to server */ | 153 | atomic_t inFlight; /* number of requests on the wire to server */ |
153 | #ifdef CONFIG_CIFS_STATS2 | 154 | #ifdef CONFIG_CIFS_STATS2 |
154 | atomic_t inSend; /* requests trying to send */ | 155 | atomic_t inSend; /* requests trying to send */ |
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c index 3bbcaa716b3c..2e9e09ca0e30 100644 --- a/fs/cifs/connect.c +++ b/fs/cifs/connect.c | |||
@@ -98,7 +98,7 @@ struct smb_vol { | |||
98 | bool nostrictsync:1; /* do not force expensive SMBflush on every sync */ | 98 | bool nostrictsync:1; /* do not force expensive SMBflush on every sync */ |
99 | unsigned int rsize; | 99 | unsigned int rsize; |
100 | unsigned int wsize; | 100 | unsigned int wsize; |
101 | unsigned int sockopt; | 101 | bool sockopt_tcp_nodelay:1; |
102 | unsigned short int port; | 102 | unsigned short int port; |
103 | char *prepath; | 103 | char *prepath; |
104 | }; | 104 | }; |
@@ -1142,9 +1142,11 @@ cifs_parse_mount_options(char *options, const char *devname, | |||
1142 | simple_strtoul(value, &value, 0); | 1142 | simple_strtoul(value, &value, 0); |
1143 | } | 1143 | } |
1144 | } else if (strnicmp(data, "sockopt", 5) == 0) { | 1144 | } else if (strnicmp(data, "sockopt", 5) == 0) { |
1145 | if (value && *value) { | 1145 | if (!value || !*value) { |
1146 | vol->sockopt = | 1146 | cERROR(1, ("no socket option specified")); |
1147 | simple_strtoul(value, &value, 0); | 1147 | continue; |
1148 | } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) { | ||
1149 | vol->sockopt_tcp_nodelay = 1; | ||
1148 | } | 1150 | } |
1149 | } else if (strnicmp(data, "netbiosname", 4) == 0) { | 1151 | } else if (strnicmp(data, "netbiosname", 4) == 0) { |
1150 | if (!value || !*value || (*value == ' ')) { | 1152 | if (!value || !*value || (*value == ' ')) { |
@@ -1514,6 +1516,7 @@ cifs_get_tcp_session(struct smb_vol *volume_info) | |||
1514 | 1516 | ||
1515 | tcp_ses->noblocksnd = volume_info->noblocksnd; | 1517 | tcp_ses->noblocksnd = volume_info->noblocksnd; |
1516 | tcp_ses->noautotune = volume_info->noautotune; | 1518 | tcp_ses->noautotune = volume_info->noautotune; |
1519 | tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay; | ||
1517 | atomic_set(&tcp_ses->inFlight, 0); | 1520 | atomic_set(&tcp_ses->inFlight, 0); |
1518 | init_waitqueue_head(&tcp_ses->response_q); | 1521 | init_waitqueue_head(&tcp_ses->response_q); |
1519 | init_waitqueue_head(&tcp_ses->request_q); | 1522 | init_waitqueue_head(&tcp_ses->request_q); |
@@ -1764,6 +1767,7 @@ static int | |||
1764 | ipv4_connect(struct TCP_Server_Info *server) | 1767 | ipv4_connect(struct TCP_Server_Info *server) |
1765 | { | 1768 | { |
1766 | int rc = 0; | 1769 | int rc = 0; |
1770 | int val; | ||
1767 | bool connected = false; | 1771 | bool connected = false; |
1768 | __be16 orig_port = 0; | 1772 | __be16 orig_port = 0; |
1769 | struct socket *socket = server->ssocket; | 1773 | struct socket *socket = server->ssocket; |
@@ -1845,6 +1849,14 @@ ipv4_connect(struct TCP_Server_Info *server) | |||
1845 | socket->sk->sk_rcvbuf = 140 * 1024; | 1849 | socket->sk->sk_rcvbuf = 140 * 1024; |
1846 | } | 1850 | } |
1847 | 1851 | ||
1852 | if (server->tcp_nodelay) { | ||
1853 | val = 1; | ||
1854 | rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY, | ||
1855 | (char *)&val, sizeof(val)); | ||
1856 | if (rc) | ||
1857 | cFYI(1, ("set TCP_NODELAY socket option error %d", rc)); | ||
1858 | } | ||
1859 | |||
1848 | cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx", | 1860 | cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx", |
1849 | socket->sk->sk_sndbuf, | 1861 | socket->sk->sk_sndbuf, |
1850 | socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo)); | 1862 | socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo)); |
@@ -1916,6 +1928,7 @@ static int | |||
1916 | ipv6_connect(struct TCP_Server_Info *server) | 1928 | ipv6_connect(struct TCP_Server_Info *server) |
1917 | { | 1929 | { |
1918 | int rc = 0; | 1930 | int rc = 0; |
1931 | int val; | ||
1919 | bool connected = false; | 1932 | bool connected = false; |
1920 | __be16 orig_port = 0; | 1933 | __be16 orig_port = 0; |
1921 | struct socket *socket = server->ssocket; | 1934 | struct socket *socket = server->ssocket; |
@@ -1987,6 +2000,15 @@ ipv6_connect(struct TCP_Server_Info *server) | |||
1987 | */ | 2000 | */ |
1988 | socket->sk->sk_rcvtimeo = 7 * HZ; | 2001 | socket->sk->sk_rcvtimeo = 7 * HZ; |
1989 | socket->sk->sk_sndtimeo = 5 * HZ; | 2002 | socket->sk->sk_sndtimeo = 5 * HZ; |
2003 | |||
2004 | if (server->tcp_nodelay) { | ||
2005 | val = 1; | ||
2006 | rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY, | ||
2007 | (char *)&val, sizeof(val)); | ||
2008 | if (rc) | ||
2009 | cFYI(1, ("set TCP_NODELAY socket option error %d", rc)); | ||
2010 | } | ||
2011 | |||
1990 | server->ssocket = socket; | 2012 | server->ssocket = socket; |
1991 | 2013 | ||
1992 | return rc; | 2014 | return rc; |
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c index cf18ee765590..e3fda978f481 100644 --- a/fs/cifs/inode.c +++ b/fs/cifs/inode.c | |||
@@ -1762,8 +1762,18 @@ cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs) | |||
1762 | CIFS_MOUNT_MAP_SPECIAL_CHR); | 1762 | CIFS_MOUNT_MAP_SPECIAL_CHR); |
1763 | } | 1763 | } |
1764 | 1764 | ||
1765 | if (!rc) | 1765 | if (!rc) { |
1766 | rc = inode_setattr(inode, attrs); | 1766 | rc = inode_setattr(inode, attrs); |
1767 | |||
1768 | /* force revalidate when any of these times are set since some | ||
1769 | of the fs types (eg ext3, fat) do not have fine enough | ||
1770 | time granularity to match protocol, and we do not have a | ||
1771 | a way (yet) to query the server fs's time granularity (and | ||
1772 | whether it rounds times down). | ||
1773 | */ | ||
1774 | if (!rc && (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))) | ||
1775 | cifsInode->time = 0; | ||
1776 | } | ||
1767 | out: | 1777 | out: |
1768 | kfree(args); | 1778 | kfree(args); |
1769 | kfree(full_path); | 1779 | kfree(full_path); |
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c index f84062f9a985..c343b14ba2d3 100644 --- a/fs/cifs/readdir.c +++ b/fs/cifs/readdir.c | |||
@@ -77,6 +77,11 @@ cifs_readdir_lookup(struct dentry *parent, struct qstr *name, | |||
77 | 77 | ||
78 | cFYI(1, ("For %s", name->name)); | 78 | cFYI(1, ("For %s", name->name)); |
79 | 79 | ||
80 | if (parent->d_op && parent->d_op->d_hash) | ||
81 | parent->d_op->d_hash(parent, name); | ||
82 | else | ||
83 | name->hash = full_name_hash(name->name, name->len); | ||
84 | |||
80 | dentry = d_lookup(parent, name); | 85 | dentry = d_lookup(parent, name); |
81 | if (dentry) { | 86 | if (dentry) { |
82 | /* FIXME: check for inode number changes? */ | 87 | /* FIXME: check for inode number changes? */ |
@@ -666,12 +671,11 @@ static int cifs_get_name_from_search_buf(struct qstr *pqst, | |||
666 | min(len, max_len), nlt, | 671 | min(len, max_len), nlt, |
667 | cifs_sb->mnt_cifs_flags & | 672 | cifs_sb->mnt_cifs_flags & |
668 | CIFS_MOUNT_MAP_SPECIAL_CHR); | 673 | CIFS_MOUNT_MAP_SPECIAL_CHR); |
674 | pqst->len -= nls_nullsize(nlt); | ||
669 | } else { | 675 | } else { |
670 | pqst->name = filename; | 676 | pqst->name = filename; |
671 | pqst->len = len; | 677 | pqst->len = len; |
672 | } | 678 | } |
673 | pqst->hash = full_name_hash(pqst->name, pqst->len); | ||
674 | /* cFYI(1, ("filldir on %s",pqst->name)); */ | ||
675 | return rc; | 679 | return rc; |
676 | } | 680 | } |
677 | 681 | ||
diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c index 7085a6275c4c..aaa9c1c5a5bd 100644 --- a/fs/cifs/sess.c +++ b/fs/cifs/sess.c | |||
@@ -223,9 +223,9 @@ static void unicode_ssetup_strings(char **pbcc_area, struct cifsSesInfo *ses, | |||
223 | /* null user mount */ | 223 | /* null user mount */ |
224 | *bcc_ptr = 0; | 224 | *bcc_ptr = 0; |
225 | *(bcc_ptr+1) = 0; | 225 | *(bcc_ptr+1) = 0; |
226 | } else { /* 300 should be long enough for any conceivable user name */ | 226 | } else { |
227 | bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->userName, | 227 | bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->userName, |
228 | 300, nls_cp); | 228 | MAX_USERNAME_SIZE, nls_cp); |
229 | } | 229 | } |
230 | bcc_ptr += 2 * bytes_ret; | 230 | bcc_ptr += 2 * bytes_ret; |
231 | bcc_ptr += 2; /* account for null termination */ | 231 | bcc_ptr += 2; /* account for null termination */ |
@@ -246,11 +246,10 @@ static void ascii_ssetup_strings(char **pbcc_area, struct cifsSesInfo *ses, | |||
246 | /* copy user */ | 246 | /* copy user */ |
247 | if (ses->userName == NULL) { | 247 | if (ses->userName == NULL) { |
248 | /* BB what about null user mounts - check that we do this BB */ | 248 | /* BB what about null user mounts - check that we do this BB */ |
249 | } else { /* 300 should be long enough for any conceivable user name */ | 249 | } else { |
250 | strncpy(bcc_ptr, ses->userName, 300); | 250 | strncpy(bcc_ptr, ses->userName, MAX_USERNAME_SIZE); |
251 | } | 251 | } |
252 | /* BB improve check for overflow */ | 252 | bcc_ptr += strnlen(ses->userName, MAX_USERNAME_SIZE); |
253 | bcc_ptr += strnlen(ses->userName, 300); | ||
254 | *bcc_ptr = 0; | 253 | *bcc_ptr = 0; |
255 | bcc_ptr++; /* account for null termination */ | 254 | bcc_ptr++; /* account for null termination */ |
256 | 255 | ||
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c index 332dd00f0894..0ca9ec4a79c3 100644 --- a/fs/compat_ioctl.c +++ b/fs/compat_ioctl.c | |||
@@ -301,6 +301,12 @@ static int sg_ioctl_trans(unsigned int fd, unsigned int cmd, | |||
301 | u32 data; | 301 | u32 data; |
302 | void __user *dxferp; | 302 | void __user *dxferp; |
303 | int err; | 303 | int err; |
304 | int interface_id; | ||
305 | |||
306 | if (get_user(interface_id, &sgio32->interface_id)) | ||
307 | return -EFAULT; | ||
308 | if (interface_id != 'S') | ||
309 | return sys_ioctl(fd, cmd, (unsigned long)sgio32); | ||
304 | 310 | ||
305 | if (get_user(iovec_count, &sgio32->iovec_count)) | 311 | if (get_user(iovec_count, &sgio32->iovec_count)) |
306 | return -EFAULT; | 312 | return -EFAULT; |
@@ -936,6 +942,7 @@ COMPATIBLE_IOCTL(TCSETSF) | |||
936 | COMPATIBLE_IOCTL(TIOCLINUX) | 942 | COMPATIBLE_IOCTL(TIOCLINUX) |
937 | COMPATIBLE_IOCTL(TIOCSBRK) | 943 | COMPATIBLE_IOCTL(TIOCSBRK) |
938 | COMPATIBLE_IOCTL(TIOCCBRK) | 944 | COMPATIBLE_IOCTL(TIOCCBRK) |
945 | COMPATIBLE_IOCTL(TIOCGSID) | ||
939 | COMPATIBLE_IOCTL(TIOCGICOUNT) | 946 | COMPATIBLE_IOCTL(TIOCGICOUNT) |
940 | /* Little t */ | 947 | /* Little t */ |
941 | COMPATIBLE_IOCTL(TIOCGETD) | 948 | COMPATIBLE_IOCTL(TIOCGETD) |
@@ -1005,6 +1012,9 @@ COMPATIBLE_IOCTL(SCSI_IOCTL_SEND_COMMAND) | |||
1005 | COMPATIBLE_IOCTL(SCSI_IOCTL_PROBE_HOST) | 1012 | COMPATIBLE_IOCTL(SCSI_IOCTL_PROBE_HOST) |
1006 | COMPATIBLE_IOCTL(SCSI_IOCTL_GET_PCI) | 1013 | COMPATIBLE_IOCTL(SCSI_IOCTL_GET_PCI) |
1007 | #endif | 1014 | #endif |
1015 | /* Big V (don't complain on serial console) */ | ||
1016 | IGNORE_IOCTL(VT_OPENQRY) | ||
1017 | IGNORE_IOCTL(VT_GETMODE) | ||
1008 | /* Little p (/dev/rtc, /dev/envctrl, etc.) */ | 1018 | /* Little p (/dev/rtc, /dev/envctrl, etc.) */ |
1009 | COMPATIBLE_IOCTL(RTC_AIE_ON) | 1019 | COMPATIBLE_IOCTL(RTC_AIE_ON) |
1010 | COMPATIBLE_IOCTL(RTC_AIE_OFF) | 1020 | COMPATIBLE_IOCTL(RTC_AIE_OFF) |
@@ -1035,6 +1045,8 @@ COMPATIBLE_IOCTL(FIOQSIZE) | |||
1035 | #ifdef CONFIG_BLOCK | 1045 | #ifdef CONFIG_BLOCK |
1036 | /* loop */ | 1046 | /* loop */ |
1037 | IGNORE_IOCTL(LOOP_CLR_FD) | 1047 | IGNORE_IOCTL(LOOP_CLR_FD) |
1048 | /* md calls this on random blockdevs */ | ||
1049 | IGNORE_IOCTL(RAID_VERSION) | ||
1038 | /* SG stuff */ | 1050 | /* SG stuff */ |
1039 | COMPATIBLE_IOCTL(SG_SET_TIMEOUT) | 1051 | COMPATIBLE_IOCTL(SG_SET_TIMEOUT) |
1040 | COMPATIBLE_IOCTL(SG_GET_TIMEOUT) | 1052 | COMPATIBLE_IOCTL(SG_GET_TIMEOUT) |
diff --git a/fs/configfs/symlink.c b/fs/configfs/symlink.c index c8afa6b1d91d..32a5f46b1157 100644 --- a/fs/configfs/symlink.c +++ b/fs/configfs/symlink.c | |||
@@ -121,8 +121,10 @@ static int get_target(const char *symname, struct path *path, | |||
121 | ret = -ENOENT; | 121 | ret = -ENOENT; |
122 | path_put(path); | 122 | path_put(path); |
123 | } | 123 | } |
124 | } else | 124 | } else { |
125 | ret = -EPERM; | 125 | ret = -EPERM; |
126 | path_put(path); | ||
127 | } | ||
126 | } | 128 | } |
127 | 129 | ||
128 | return ret; | 130 | return ret; |
diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c index b486169f42bf..274ac865bae8 100644 --- a/fs/debugfs/inode.c +++ b/fs/debugfs/inode.c | |||
@@ -160,15 +160,8 @@ static int debugfs_create_by_name(const char *name, mode_t mode, | |||
160 | * block. A pointer to that is in the struct vfsmount that we | 160 | * block. A pointer to that is in the struct vfsmount that we |
161 | * have around. | 161 | * have around. |
162 | */ | 162 | */ |
163 | if (!parent) { | 163 | if (!parent) |
164 | if (debugfs_mount && debugfs_mount->mnt_sb) { | 164 | parent = debugfs_mount->mnt_sb->s_root; |
165 | parent = debugfs_mount->mnt_sb->s_root; | ||
166 | } | ||
167 | } | ||
168 | if (!parent) { | ||
169 | pr_debug("debugfs: Ah! can not find a parent!\n"); | ||
170 | return -EFAULT; | ||
171 | } | ||
172 | 165 | ||
173 | *dentry = NULL; | 166 | *dentry = NULL; |
174 | mutex_lock(&parent->d_inode->i_mutex); | 167 | mutex_lock(&parent->d_inode->i_mutex); |
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c index fbb6e5eed697..7cb0a59f4b9d 100644 --- a/fs/ecryptfs/crypto.c +++ b/fs/ecryptfs/crypto.c | |||
@@ -1748,7 +1748,7 @@ ecryptfs_process_key_cipher(struct crypto_blkcipher **key_tfm, | |||
1748 | char *cipher_name, size_t *key_size) | 1748 | char *cipher_name, size_t *key_size) |
1749 | { | 1749 | { |
1750 | char dummy_key[ECRYPTFS_MAX_KEY_BYTES]; | 1750 | char dummy_key[ECRYPTFS_MAX_KEY_BYTES]; |
1751 | char *full_alg_name; | 1751 | char *full_alg_name = NULL; |
1752 | int rc; | 1752 | int rc; |
1753 | 1753 | ||
1754 | *key_tfm = NULL; | 1754 | *key_tfm = NULL; |
@@ -1763,7 +1763,6 @@ ecryptfs_process_key_cipher(struct crypto_blkcipher **key_tfm, | |||
1763 | if (rc) | 1763 | if (rc) |
1764 | goto out; | 1764 | goto out; |
1765 | *key_tfm = crypto_alloc_blkcipher(full_alg_name, 0, CRYPTO_ALG_ASYNC); | 1765 | *key_tfm = crypto_alloc_blkcipher(full_alg_name, 0, CRYPTO_ALG_ASYNC); |
1766 | kfree(full_alg_name); | ||
1767 | if (IS_ERR(*key_tfm)) { | 1766 | if (IS_ERR(*key_tfm)) { |
1768 | rc = PTR_ERR(*key_tfm); | 1767 | rc = PTR_ERR(*key_tfm); |
1769 | printk(KERN_ERR "Unable to allocate crypto cipher with name " | 1768 | printk(KERN_ERR "Unable to allocate crypto cipher with name " |
@@ -1786,6 +1785,7 @@ ecryptfs_process_key_cipher(struct crypto_blkcipher **key_tfm, | |||
1786 | goto out; | 1785 | goto out; |
1787 | } | 1786 | } |
1788 | out: | 1787 | out: |
1788 | kfree(full_alg_name); | ||
1789 | return rc; | 1789 | return rc; |
1790 | } | 1790 | } |
1791 | 1791 | ||
diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c index 9e944057001b..678172b61be2 100644 --- a/fs/ecryptfs/file.c +++ b/fs/ecryptfs/file.c | |||
@@ -158,7 +158,7 @@ static int ecryptfs_open(struct inode *inode, struct file *file) | |||
158 | struct dentry *ecryptfs_dentry = file->f_path.dentry; | 158 | struct dentry *ecryptfs_dentry = file->f_path.dentry; |
159 | /* Private value of ecryptfs_dentry allocated in | 159 | /* Private value of ecryptfs_dentry allocated in |
160 | * ecryptfs_lookup() */ | 160 | * ecryptfs_lookup() */ |
161 | struct dentry *lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry); | 161 | struct dentry *lower_dentry; |
162 | struct ecryptfs_file_info *file_info; | 162 | struct ecryptfs_file_info *file_info; |
163 | 163 | ||
164 | mount_crypt_stat = &ecryptfs_superblock_to_private( | 164 | mount_crypt_stat = &ecryptfs_superblock_to_private( |
@@ -191,13 +191,6 @@ static int ecryptfs_open(struct inode *inode, struct file *file) | |||
191 | | ECRYPTFS_ENCRYPTED); | 191 | | ECRYPTFS_ENCRYPTED); |
192 | } | 192 | } |
193 | mutex_unlock(&crypt_stat->cs_mutex); | 193 | mutex_unlock(&crypt_stat->cs_mutex); |
194 | if ((ecryptfs_inode_to_private(inode)->lower_file->f_flags & O_RDONLY) | ||
195 | && !(file->f_flags & O_RDONLY)) { | ||
196 | rc = -EPERM; | ||
197 | printk(KERN_WARNING "%s: Lower persistent file is RO; eCryptfs " | ||
198 | "file must hence be opened RO\n", __func__); | ||
199 | goto out; | ||
200 | } | ||
201 | if (!ecryptfs_inode_to_private(inode)->lower_file) { | 194 | if (!ecryptfs_inode_to_private(inode)->lower_file) { |
202 | rc = ecryptfs_init_persistent_file(ecryptfs_dentry); | 195 | rc = ecryptfs_init_persistent_file(ecryptfs_dentry); |
203 | if (rc) { | 196 | if (rc) { |
@@ -208,6 +201,13 @@ static int ecryptfs_open(struct inode *inode, struct file *file) | |||
208 | goto out; | 201 | goto out; |
209 | } | 202 | } |
210 | } | 203 | } |
204 | if ((ecryptfs_inode_to_private(inode)->lower_file->f_flags & O_RDONLY) | ||
205 | && !(file->f_flags & O_RDONLY)) { | ||
206 | rc = -EPERM; | ||
207 | printk(KERN_WARNING "%s: Lower persistent file is RO; eCryptfs " | ||
208 | "file must hence be opened RO\n", __func__); | ||
209 | goto out; | ||
210 | } | ||
211 | ecryptfs_set_file_lower( | 211 | ecryptfs_set_file_lower( |
212 | file, ecryptfs_inode_to_private(inode)->lower_file); | 212 | file, ecryptfs_inode_to_private(inode)->lower_file); |
213 | if (S_ISDIR(ecryptfs_dentry->d_inode->i_mode)) { | 213 | if (S_ISDIR(ecryptfs_dentry->d_inode->i_mode)) { |
@@ -299,7 +299,6 @@ static int ecryptfs_ioctl(struct inode *inode, struct file *file, | |||
299 | const struct file_operations ecryptfs_dir_fops = { | 299 | const struct file_operations ecryptfs_dir_fops = { |
300 | .readdir = ecryptfs_readdir, | 300 | .readdir = ecryptfs_readdir, |
301 | .ioctl = ecryptfs_ioctl, | 301 | .ioctl = ecryptfs_ioctl, |
302 | .mmap = generic_file_mmap, | ||
303 | .open = ecryptfs_open, | 302 | .open = ecryptfs_open, |
304 | .flush = ecryptfs_flush, | 303 | .flush = ecryptfs_flush, |
305 | .release = ecryptfs_release, | 304 | .release = ecryptfs_release, |
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c index 429ca0b3ba08..4a430ab4115c 100644 --- a/fs/ecryptfs/inode.c +++ b/fs/ecryptfs/inode.c | |||
@@ -282,7 +282,8 @@ int ecryptfs_lookup_and_interpose_lower(struct dentry *ecryptfs_dentry, | |||
282 | goto out; | 282 | goto out; |
283 | } | 283 | } |
284 | rc = ecryptfs_interpose(lower_dentry, ecryptfs_dentry, | 284 | rc = ecryptfs_interpose(lower_dentry, ecryptfs_dentry, |
285 | ecryptfs_dir_inode->i_sb, 1); | 285 | ecryptfs_dir_inode->i_sb, |
286 | ECRYPTFS_INTERPOSE_FLAG_D_ADD); | ||
286 | if (rc) { | 287 | if (rc) { |
287 | printk(KERN_ERR "%s: Error interposing; rc = [%d]\n", | 288 | printk(KERN_ERR "%s: Error interposing; rc = [%d]\n", |
288 | __func__, rc); | 289 | __func__, rc); |
@@ -463,9 +464,6 @@ out_lock: | |||
463 | unlock_dir(lower_dir_dentry); | 464 | unlock_dir(lower_dir_dentry); |
464 | dput(lower_new_dentry); | 465 | dput(lower_new_dentry); |
465 | dput(lower_old_dentry); | 466 | dput(lower_old_dentry); |
466 | d_drop(lower_old_dentry); | ||
467 | d_drop(new_dentry); | ||
468 | d_drop(old_dentry); | ||
469 | return rc; | 467 | return rc; |
470 | } | 468 | } |
471 | 469 | ||
@@ -614,6 +612,7 @@ ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry, | |||
614 | struct dentry *lower_new_dentry; | 612 | struct dentry *lower_new_dentry; |
615 | struct dentry *lower_old_dir_dentry; | 613 | struct dentry *lower_old_dir_dentry; |
616 | struct dentry *lower_new_dir_dentry; | 614 | struct dentry *lower_new_dir_dentry; |
615 | struct dentry *trap = NULL; | ||
617 | 616 | ||
618 | lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry); | 617 | lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry); |
619 | lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry); | 618 | lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry); |
@@ -621,7 +620,17 @@ ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry, | |||
621 | dget(lower_new_dentry); | 620 | dget(lower_new_dentry); |
622 | lower_old_dir_dentry = dget_parent(lower_old_dentry); | 621 | lower_old_dir_dentry = dget_parent(lower_old_dentry); |
623 | lower_new_dir_dentry = dget_parent(lower_new_dentry); | 622 | lower_new_dir_dentry = dget_parent(lower_new_dentry); |
624 | lock_rename(lower_old_dir_dentry, lower_new_dir_dentry); | 623 | trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry); |
624 | /* source should not be ancestor of target */ | ||
625 | if (trap == lower_old_dentry) { | ||
626 | rc = -EINVAL; | ||
627 | goto out_lock; | ||
628 | } | ||
629 | /* target should not be ancestor of source */ | ||
630 | if (trap == lower_new_dentry) { | ||
631 | rc = -ENOTEMPTY; | ||
632 | goto out_lock; | ||
633 | } | ||
625 | rc = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry, | 634 | rc = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry, |
626 | lower_new_dir_dentry->d_inode, lower_new_dentry); | 635 | lower_new_dir_dentry->d_inode, lower_new_dentry); |
627 | if (rc) | 636 | if (rc) |
@@ -715,31 +724,31 @@ static void *ecryptfs_follow_link(struct dentry *dentry, struct nameidata *nd) | |||
715 | /* Released in ecryptfs_put_link(); only release here on error */ | 724 | /* Released in ecryptfs_put_link(); only release here on error */ |
716 | buf = kmalloc(len, GFP_KERNEL); | 725 | buf = kmalloc(len, GFP_KERNEL); |
717 | if (!buf) { | 726 | if (!buf) { |
718 | rc = -ENOMEM; | 727 | buf = ERR_PTR(-ENOMEM); |
719 | goto out; | 728 | goto out; |
720 | } | 729 | } |
721 | old_fs = get_fs(); | 730 | old_fs = get_fs(); |
722 | set_fs(get_ds()); | 731 | set_fs(get_ds()); |
723 | rc = dentry->d_inode->i_op->readlink(dentry, (char __user *)buf, len); | 732 | rc = dentry->d_inode->i_op->readlink(dentry, (char __user *)buf, len); |
724 | set_fs(old_fs); | 733 | set_fs(old_fs); |
725 | if (rc < 0) | 734 | if (rc < 0) { |
726 | goto out_free; | 735 | kfree(buf); |
727 | else | 736 | buf = ERR_PTR(rc); |
737 | } else | ||
728 | buf[rc] = '\0'; | 738 | buf[rc] = '\0'; |
729 | rc = 0; | ||
730 | nd_set_link(nd, buf); | ||
731 | goto out; | ||
732 | out_free: | ||
733 | kfree(buf); | ||
734 | out: | 739 | out: |
735 | return ERR_PTR(rc); | 740 | nd_set_link(nd, buf); |
741 | return NULL; | ||
736 | } | 742 | } |
737 | 743 | ||
738 | static void | 744 | static void |
739 | ecryptfs_put_link(struct dentry *dentry, struct nameidata *nd, void *ptr) | 745 | ecryptfs_put_link(struct dentry *dentry, struct nameidata *nd, void *ptr) |
740 | { | 746 | { |
741 | /* Free the char* */ | 747 | char *buf = nd_get_link(nd); |
742 | kfree(nd_get_link(nd)); | 748 | if (!IS_ERR(buf)) { |
749 | /* Free the char* */ | ||
750 | kfree(buf); | ||
751 | } | ||
743 | } | 752 | } |
744 | 753 | ||
745 | /** | 754 | /** |
@@ -772,18 +781,23 @@ upper_size_to_lower_size(struct ecryptfs_crypt_stat *crypt_stat, | |||
772 | } | 781 | } |
773 | 782 | ||
774 | /** | 783 | /** |
775 | * ecryptfs_truncate | 784 | * truncate_upper |
776 | * @dentry: The ecryptfs layer dentry | 785 | * @dentry: The ecryptfs layer dentry |
777 | * @new_length: The length to expand the file to | 786 | * @ia: Address of the ecryptfs inode's attributes |
787 | * @lower_ia: Address of the lower inode's attributes | ||
778 | * | 788 | * |
779 | * Function to handle truncations modifying the size of the file. Note | 789 | * Function to handle truncations modifying the size of the file. Note |
780 | * that the file sizes are interpolated. When expanding, we are simply | 790 | * that the file sizes are interpolated. When expanding, we are simply |
781 | * writing strings of 0's out. When truncating, we need to modify the | 791 | * writing strings of 0's out. When truncating, we truncate the upper |
782 | * underlying file size according to the page index interpolations. | 792 | * inode and update the lower_ia according to the page index |
793 | * interpolations. If ATTR_SIZE is set in lower_ia->ia_valid upon return, | ||
794 | * the caller must use lower_ia in a call to notify_change() to perform | ||
795 | * the truncation of the lower inode. | ||
783 | * | 796 | * |
784 | * Returns zero on success; non-zero otherwise | 797 | * Returns zero on success; non-zero otherwise |
785 | */ | 798 | */ |
786 | int ecryptfs_truncate(struct dentry *dentry, loff_t new_length) | 799 | static int truncate_upper(struct dentry *dentry, struct iattr *ia, |
800 | struct iattr *lower_ia) | ||
787 | { | 801 | { |
788 | int rc = 0; | 802 | int rc = 0; |
789 | struct inode *inode = dentry->d_inode; | 803 | struct inode *inode = dentry->d_inode; |
@@ -794,8 +808,10 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length) | |||
794 | loff_t lower_size_before_truncate; | 808 | loff_t lower_size_before_truncate; |
795 | loff_t lower_size_after_truncate; | 809 | loff_t lower_size_after_truncate; |
796 | 810 | ||
797 | if (unlikely((new_length == i_size))) | 811 | if (unlikely((ia->ia_size == i_size))) { |
812 | lower_ia->ia_valid &= ~ATTR_SIZE; | ||
798 | goto out; | 813 | goto out; |
814 | } | ||
799 | crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat; | 815 | crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat; |
800 | /* Set up a fake ecryptfs file, this is used to interface with | 816 | /* Set up a fake ecryptfs file, this is used to interface with |
801 | * the file in the underlying filesystem so that the | 817 | * the file in the underlying filesystem so that the |
@@ -815,28 +831,30 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length) | |||
815 | &fake_ecryptfs_file, | 831 | &fake_ecryptfs_file, |
816 | ecryptfs_inode_to_private(dentry->d_inode)->lower_file); | 832 | ecryptfs_inode_to_private(dentry->d_inode)->lower_file); |
817 | /* Switch on growing or shrinking file */ | 833 | /* Switch on growing or shrinking file */ |
818 | if (new_length > i_size) { | 834 | if (ia->ia_size > i_size) { |
819 | char zero[] = { 0x00 }; | 835 | char zero[] = { 0x00 }; |
820 | 836 | ||
837 | lower_ia->ia_valid &= ~ATTR_SIZE; | ||
821 | /* Write a single 0 at the last position of the file; | 838 | /* Write a single 0 at the last position of the file; |
822 | * this triggers code that will fill in 0's throughout | 839 | * this triggers code that will fill in 0's throughout |
823 | * the intermediate portion of the previous end of the | 840 | * the intermediate portion of the previous end of the |
824 | * file and the new and of the file */ | 841 | * file and the new and of the file */ |
825 | rc = ecryptfs_write(&fake_ecryptfs_file, zero, | 842 | rc = ecryptfs_write(&fake_ecryptfs_file, zero, |
826 | (new_length - 1), 1); | 843 | (ia->ia_size - 1), 1); |
827 | } else { /* new_length < i_size_read(inode) */ | 844 | } else { /* ia->ia_size < i_size_read(inode) */ |
828 | /* We're chopping off all the pages down do the page | 845 | /* We're chopping off all the pages down to the page |
829 | * in which new_length is located. Fill in the end of | 846 | * in which ia->ia_size is located. Fill in the end of |
830 | * that page from (new_length & ~PAGE_CACHE_MASK) to | 847 | * that page from (ia->ia_size & ~PAGE_CACHE_MASK) to |
831 | * PAGE_CACHE_SIZE with zeros. */ | 848 | * PAGE_CACHE_SIZE with zeros. */ |
832 | size_t num_zeros = (PAGE_CACHE_SIZE | 849 | size_t num_zeros = (PAGE_CACHE_SIZE |
833 | - (new_length & ~PAGE_CACHE_MASK)); | 850 | - (ia->ia_size & ~PAGE_CACHE_MASK)); |
834 | 851 | ||
835 | if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) { | 852 | if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) { |
836 | rc = vmtruncate(inode, new_length); | 853 | rc = vmtruncate(inode, ia->ia_size); |
837 | if (rc) | 854 | if (rc) |
838 | goto out_free; | 855 | goto out_free; |
839 | rc = vmtruncate(lower_dentry->d_inode, new_length); | 856 | lower_ia->ia_size = ia->ia_size; |
857 | lower_ia->ia_valid |= ATTR_SIZE; | ||
840 | goto out_free; | 858 | goto out_free; |
841 | } | 859 | } |
842 | if (num_zeros) { | 860 | if (num_zeros) { |
@@ -848,7 +866,7 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length) | |||
848 | goto out_free; | 866 | goto out_free; |
849 | } | 867 | } |
850 | rc = ecryptfs_write(&fake_ecryptfs_file, zeros_virt, | 868 | rc = ecryptfs_write(&fake_ecryptfs_file, zeros_virt, |
851 | new_length, num_zeros); | 869 | ia->ia_size, num_zeros); |
852 | kfree(zeros_virt); | 870 | kfree(zeros_virt); |
853 | if (rc) { | 871 | if (rc) { |
854 | printk(KERN_ERR "Error attempting to zero out " | 872 | printk(KERN_ERR "Error attempting to zero out " |
@@ -857,7 +875,7 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length) | |||
857 | goto out_free; | 875 | goto out_free; |
858 | } | 876 | } |
859 | } | 877 | } |
860 | vmtruncate(inode, new_length); | 878 | vmtruncate(inode, ia->ia_size); |
861 | rc = ecryptfs_write_inode_size_to_metadata(inode); | 879 | rc = ecryptfs_write_inode_size_to_metadata(inode); |
862 | if (rc) { | 880 | if (rc) { |
863 | printk(KERN_ERR "Problem with " | 881 | printk(KERN_ERR "Problem with " |
@@ -870,10 +888,12 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length) | |||
870 | lower_size_before_truncate = | 888 | lower_size_before_truncate = |
871 | upper_size_to_lower_size(crypt_stat, i_size); | 889 | upper_size_to_lower_size(crypt_stat, i_size); |
872 | lower_size_after_truncate = | 890 | lower_size_after_truncate = |
873 | upper_size_to_lower_size(crypt_stat, new_length); | 891 | upper_size_to_lower_size(crypt_stat, ia->ia_size); |
874 | if (lower_size_after_truncate < lower_size_before_truncate) | 892 | if (lower_size_after_truncate < lower_size_before_truncate) { |
875 | vmtruncate(lower_dentry->d_inode, | 893 | lower_ia->ia_size = lower_size_after_truncate; |
876 | lower_size_after_truncate); | 894 | lower_ia->ia_valid |= ATTR_SIZE; |
895 | } else | ||
896 | lower_ia->ia_valid &= ~ATTR_SIZE; | ||
877 | } | 897 | } |
878 | out_free: | 898 | out_free: |
879 | if (ecryptfs_file_to_private(&fake_ecryptfs_file)) | 899 | if (ecryptfs_file_to_private(&fake_ecryptfs_file)) |
@@ -883,6 +903,33 @@ out: | |||
883 | return rc; | 903 | return rc; |
884 | } | 904 | } |
885 | 905 | ||
906 | /** | ||
907 | * ecryptfs_truncate | ||
908 | * @dentry: The ecryptfs layer dentry | ||
909 | * @new_length: The length to expand the file to | ||
910 | * | ||
911 | * Simple function that handles the truncation of an eCryptfs inode and | ||
912 | * its corresponding lower inode. | ||
913 | * | ||
914 | * Returns zero on success; non-zero otherwise | ||
915 | */ | ||
916 | int ecryptfs_truncate(struct dentry *dentry, loff_t new_length) | ||
917 | { | ||
918 | struct iattr ia = { .ia_valid = ATTR_SIZE, .ia_size = new_length }; | ||
919 | struct iattr lower_ia = { .ia_valid = 0 }; | ||
920 | int rc; | ||
921 | |||
922 | rc = truncate_upper(dentry, &ia, &lower_ia); | ||
923 | if (!rc && lower_ia.ia_valid & ATTR_SIZE) { | ||
924 | struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry); | ||
925 | |||
926 | mutex_lock(&lower_dentry->d_inode->i_mutex); | ||
927 | rc = notify_change(lower_dentry, &lower_ia); | ||
928 | mutex_unlock(&lower_dentry->d_inode->i_mutex); | ||
929 | } | ||
930 | return rc; | ||
931 | } | ||
932 | |||
886 | static int | 933 | static int |
887 | ecryptfs_permission(struct inode *inode, int mask) | 934 | ecryptfs_permission(struct inode *inode, int mask) |
888 | { | 935 | { |
@@ -905,6 +952,7 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia) | |||
905 | { | 952 | { |
906 | int rc = 0; | 953 | int rc = 0; |
907 | struct dentry *lower_dentry; | 954 | struct dentry *lower_dentry; |
955 | struct iattr lower_ia; | ||
908 | struct inode *inode; | 956 | struct inode *inode; |
909 | struct inode *lower_inode; | 957 | struct inode *lower_inode; |
910 | struct ecryptfs_crypt_stat *crypt_stat; | 958 | struct ecryptfs_crypt_stat *crypt_stat; |
@@ -943,15 +991,11 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia) | |||
943 | } | 991 | } |
944 | } | 992 | } |
945 | mutex_unlock(&crypt_stat->cs_mutex); | 993 | mutex_unlock(&crypt_stat->cs_mutex); |
994 | memcpy(&lower_ia, ia, sizeof(lower_ia)); | ||
995 | if (ia->ia_valid & ATTR_FILE) | ||
996 | lower_ia.ia_file = ecryptfs_file_to_lower(ia->ia_file); | ||
946 | if (ia->ia_valid & ATTR_SIZE) { | 997 | if (ia->ia_valid & ATTR_SIZE) { |
947 | ecryptfs_printk(KERN_DEBUG, | 998 | rc = truncate_upper(dentry, ia, &lower_ia); |
948 | "ia->ia_valid = [0x%x] ATTR_SIZE" " = [0x%x]\n", | ||
949 | ia->ia_valid, ATTR_SIZE); | ||
950 | rc = ecryptfs_truncate(dentry, ia->ia_size); | ||
951 | /* ecryptfs_truncate handles resizing of the lower file */ | ||
952 | ia->ia_valid &= ~ATTR_SIZE; | ||
953 | ecryptfs_printk(KERN_DEBUG, "ia->ia_valid = [%x]\n", | ||
954 | ia->ia_valid); | ||
955 | if (rc < 0) | 999 | if (rc < 0) |
956 | goto out; | 1000 | goto out; |
957 | } | 1001 | } |
@@ -960,17 +1004,32 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia) | |||
960 | * mode change is for clearing setuid/setgid bits. Allow lower fs | 1004 | * mode change is for clearing setuid/setgid bits. Allow lower fs |
961 | * to interpret this in its own way. | 1005 | * to interpret this in its own way. |
962 | */ | 1006 | */ |
963 | if (ia->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) | 1007 | if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) |
964 | ia->ia_valid &= ~ATTR_MODE; | 1008 | lower_ia.ia_valid &= ~ATTR_MODE; |
965 | 1009 | ||
966 | mutex_lock(&lower_dentry->d_inode->i_mutex); | 1010 | mutex_lock(&lower_dentry->d_inode->i_mutex); |
967 | rc = notify_change(lower_dentry, ia); | 1011 | rc = notify_change(lower_dentry, &lower_ia); |
968 | mutex_unlock(&lower_dentry->d_inode->i_mutex); | 1012 | mutex_unlock(&lower_dentry->d_inode->i_mutex); |
969 | out: | 1013 | out: |
970 | fsstack_copy_attr_all(inode, lower_inode); | 1014 | fsstack_copy_attr_all(inode, lower_inode); |
971 | return rc; | 1015 | return rc; |
972 | } | 1016 | } |
973 | 1017 | ||
1018 | int ecryptfs_getattr(struct vfsmount *mnt, struct dentry *dentry, | ||
1019 | struct kstat *stat) | ||
1020 | { | ||
1021 | struct kstat lower_stat; | ||
1022 | int rc; | ||
1023 | |||
1024 | rc = vfs_getattr(ecryptfs_dentry_to_lower_mnt(dentry), | ||
1025 | ecryptfs_dentry_to_lower(dentry), &lower_stat); | ||
1026 | if (!rc) { | ||
1027 | generic_fillattr(dentry->d_inode, stat); | ||
1028 | stat->blocks = lower_stat.blocks; | ||
1029 | } | ||
1030 | return rc; | ||
1031 | } | ||
1032 | |||
974 | int | 1033 | int |
975 | ecryptfs_setxattr(struct dentry *dentry, const char *name, const void *value, | 1034 | ecryptfs_setxattr(struct dentry *dentry, const char *name, const void *value, |
976 | size_t size, int flags) | 1035 | size_t size, int flags) |
@@ -1100,6 +1159,7 @@ const struct inode_operations ecryptfs_dir_iops = { | |||
1100 | const struct inode_operations ecryptfs_main_iops = { | 1159 | const struct inode_operations ecryptfs_main_iops = { |
1101 | .permission = ecryptfs_permission, | 1160 | .permission = ecryptfs_permission, |
1102 | .setattr = ecryptfs_setattr, | 1161 | .setattr = ecryptfs_setattr, |
1162 | .getattr = ecryptfs_getattr, | ||
1103 | .setxattr = ecryptfs_setxattr, | 1163 | .setxattr = ecryptfs_setxattr, |
1104 | .getxattr = ecryptfs_getxattr, | 1164 | .getxattr = ecryptfs_getxattr, |
1105 | .listxattr = ecryptfs_listxattr, | 1165 | .listxattr = ecryptfs_listxattr, |
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c index 567bc4b9f70a..ea2f92101dfe 100644 --- a/fs/ecryptfs/main.c +++ b/fs/ecryptfs/main.c | |||
@@ -585,8 +585,8 @@ out: | |||
585 | * with as much information as it can before needing | 585 | * with as much information as it can before needing |
586 | * the lower filesystem. | 586 | * the lower filesystem. |
587 | * ecryptfs_read_super(): this accesses the lower filesystem and uses | 587 | * ecryptfs_read_super(): this accesses the lower filesystem and uses |
588 | * ecryptfs_interpolate to perform most of the linking | 588 | * ecryptfs_interpose to perform most of the linking |
589 | * ecryptfs_interpolate(): links the lower filesystem into ecryptfs | 589 | * ecryptfs_interpose(): links the lower filesystem into ecryptfs (inode.c) |
590 | */ | 590 | */ |
591 | static int ecryptfs_get_sb(struct file_system_type *fs_type, int flags, | 591 | static int ecryptfs_get_sb(struct file_system_type *fs_type, int flags, |
592 | const char *dev_name, void *raw_data, | 592 | const char *dev_name, void *raw_data, |
diff --git a/fs/eventfd.c b/fs/eventfd.c index d26402ff06ea..7758cc382ef0 100644 --- a/fs/eventfd.c +++ b/fs/eventfd.c | |||
@@ -135,26 +135,71 @@ static unsigned int eventfd_poll(struct file *file, poll_table *wait) | |||
135 | return events; | 135 | return events; |
136 | } | 136 | } |
137 | 137 | ||
138 | static ssize_t eventfd_read(struct file *file, char __user *buf, size_t count, | 138 | static void eventfd_ctx_do_read(struct eventfd_ctx *ctx, __u64 *cnt) |
139 | loff_t *ppos) | 139 | { |
140 | *cnt = (ctx->flags & EFD_SEMAPHORE) ? 1 : ctx->count; | ||
141 | ctx->count -= *cnt; | ||
142 | } | ||
143 | |||
144 | /** | ||
145 | * eventfd_ctx_remove_wait_queue - Read the current counter and removes wait queue. | ||
146 | * @ctx: [in] Pointer to eventfd context. | ||
147 | * @wait: [in] Wait queue to be removed. | ||
148 | * @cnt: [out] Pointer to the 64bit conter value. | ||
149 | * | ||
150 | * Returns zero if successful, or the following error codes: | ||
151 | * | ||
152 | * -EAGAIN : The operation would have blocked. | ||
153 | * | ||
154 | * This is used to atomically remove a wait queue entry from the eventfd wait | ||
155 | * queue head, and read/reset the counter value. | ||
156 | */ | ||
157 | int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, wait_queue_t *wait, | ||
158 | __u64 *cnt) | ||
159 | { | ||
160 | unsigned long flags; | ||
161 | |||
162 | spin_lock_irqsave(&ctx->wqh.lock, flags); | ||
163 | eventfd_ctx_do_read(ctx, cnt); | ||
164 | __remove_wait_queue(&ctx->wqh, wait); | ||
165 | if (*cnt != 0 && waitqueue_active(&ctx->wqh)) | ||
166 | wake_up_locked_poll(&ctx->wqh, POLLOUT); | ||
167 | spin_unlock_irqrestore(&ctx->wqh.lock, flags); | ||
168 | |||
169 | return *cnt != 0 ? 0 : -EAGAIN; | ||
170 | } | ||
171 | EXPORT_SYMBOL_GPL(eventfd_ctx_remove_wait_queue); | ||
172 | |||
173 | /** | ||
174 | * eventfd_ctx_read - Reads the eventfd counter or wait if it is zero. | ||
175 | * @ctx: [in] Pointer to eventfd context. | ||
176 | * @no_wait: [in] Different from zero if the operation should not block. | ||
177 | * @cnt: [out] Pointer to the 64bit conter value. | ||
178 | * | ||
179 | * Returns zero if successful, or the following error codes: | ||
180 | * | ||
181 | * -EAGAIN : The operation would have blocked but @no_wait was nonzero. | ||
182 | * -ERESTARTSYS : A signal interrupted the wait operation. | ||
183 | * | ||
184 | * If @no_wait is zero, the function might sleep until the eventfd internal | ||
185 | * counter becomes greater than zero. | ||
186 | */ | ||
187 | ssize_t eventfd_ctx_read(struct eventfd_ctx *ctx, int no_wait, __u64 *cnt) | ||
140 | { | 188 | { |
141 | struct eventfd_ctx *ctx = file->private_data; | ||
142 | ssize_t res; | 189 | ssize_t res; |
143 | __u64 ucnt = 0; | ||
144 | DECLARE_WAITQUEUE(wait, current); | 190 | DECLARE_WAITQUEUE(wait, current); |
145 | 191 | ||
146 | if (count < sizeof(ucnt)) | ||
147 | return -EINVAL; | ||
148 | spin_lock_irq(&ctx->wqh.lock); | 192 | spin_lock_irq(&ctx->wqh.lock); |
193 | *cnt = 0; | ||
149 | res = -EAGAIN; | 194 | res = -EAGAIN; |
150 | if (ctx->count > 0) | 195 | if (ctx->count > 0) |
151 | res = sizeof(ucnt); | 196 | res = 0; |
152 | else if (!(file->f_flags & O_NONBLOCK)) { | 197 | else if (!no_wait) { |
153 | __add_wait_queue(&ctx->wqh, &wait); | 198 | __add_wait_queue(&ctx->wqh, &wait); |
154 | for (res = 0;;) { | 199 | for (;;) { |
155 | set_current_state(TASK_INTERRUPTIBLE); | 200 | set_current_state(TASK_INTERRUPTIBLE); |
156 | if (ctx->count > 0) { | 201 | if (ctx->count > 0) { |
157 | res = sizeof(ucnt); | 202 | res = 0; |
158 | break; | 203 | break; |
159 | } | 204 | } |
160 | if (signal_pending(current)) { | 205 | if (signal_pending(current)) { |
@@ -168,18 +213,32 @@ static ssize_t eventfd_read(struct file *file, char __user *buf, size_t count, | |||
168 | __remove_wait_queue(&ctx->wqh, &wait); | 213 | __remove_wait_queue(&ctx->wqh, &wait); |
169 | __set_current_state(TASK_RUNNING); | 214 | __set_current_state(TASK_RUNNING); |
170 | } | 215 | } |
171 | if (likely(res > 0)) { | 216 | if (likely(res == 0)) { |
172 | ucnt = (ctx->flags & EFD_SEMAPHORE) ? 1 : ctx->count; | 217 | eventfd_ctx_do_read(ctx, cnt); |
173 | ctx->count -= ucnt; | ||
174 | if (waitqueue_active(&ctx->wqh)) | 218 | if (waitqueue_active(&ctx->wqh)) |
175 | wake_up_locked_poll(&ctx->wqh, POLLOUT); | 219 | wake_up_locked_poll(&ctx->wqh, POLLOUT); |
176 | } | 220 | } |
177 | spin_unlock_irq(&ctx->wqh.lock); | 221 | spin_unlock_irq(&ctx->wqh.lock); |
178 | if (res > 0 && put_user(ucnt, (__u64 __user *) buf)) | ||
179 | return -EFAULT; | ||
180 | 222 | ||
181 | return res; | 223 | return res; |
182 | } | 224 | } |
225 | EXPORT_SYMBOL_GPL(eventfd_ctx_read); | ||
226 | |||
227 | static ssize_t eventfd_read(struct file *file, char __user *buf, size_t count, | ||
228 | loff_t *ppos) | ||
229 | { | ||
230 | struct eventfd_ctx *ctx = file->private_data; | ||
231 | ssize_t res; | ||
232 | __u64 cnt; | ||
233 | |||
234 | if (count < sizeof(cnt)) | ||
235 | return -EINVAL; | ||
236 | res = eventfd_ctx_read(ctx, file->f_flags & O_NONBLOCK, &cnt); | ||
237 | if (res < 0) | ||
238 | return res; | ||
239 | |||
240 | return put_user(cnt, (__u64 __user *) buf) ? -EFAULT : sizeof(cnt); | ||
241 | } | ||
183 | 242 | ||
184 | static ssize_t eventfd_write(struct file *file, const char __user *buf, size_t count, | 243 | static ssize_t eventfd_write(struct file *file, const char __user *buf, size_t count, |
185 | loff_t *ppos) | 244 | loff_t *ppos) |
@@ -571,6 +571,9 @@ int setup_arg_pages(struct linux_binprm *bprm, | |||
571 | struct vm_area_struct *prev = NULL; | 571 | struct vm_area_struct *prev = NULL; |
572 | unsigned long vm_flags; | 572 | unsigned long vm_flags; |
573 | unsigned long stack_base; | 573 | unsigned long stack_base; |
574 | unsigned long stack_size; | ||
575 | unsigned long stack_expand; | ||
576 | unsigned long rlim_stack; | ||
574 | 577 | ||
575 | #ifdef CONFIG_STACK_GROWSUP | 578 | #ifdef CONFIG_STACK_GROWSUP |
576 | /* Limit stack size to 1GB */ | 579 | /* Limit stack size to 1GB */ |
@@ -627,10 +630,23 @@ int setup_arg_pages(struct linux_binprm *bprm, | |||
627 | goto out_unlock; | 630 | goto out_unlock; |
628 | } | 631 | } |
629 | 632 | ||
633 | stack_expand = EXTRA_STACK_VM_PAGES * PAGE_SIZE; | ||
634 | stack_size = vma->vm_end - vma->vm_start; | ||
635 | /* | ||
636 | * Align this down to a page boundary as expand_stack | ||
637 | * will align it up. | ||
638 | */ | ||
639 | rlim_stack = rlimit(RLIMIT_STACK) & PAGE_MASK; | ||
630 | #ifdef CONFIG_STACK_GROWSUP | 640 | #ifdef CONFIG_STACK_GROWSUP |
631 | stack_base = vma->vm_end + EXTRA_STACK_VM_PAGES * PAGE_SIZE; | 641 | if (stack_size + stack_expand > rlim_stack) |
642 | stack_base = vma->vm_start + rlim_stack; | ||
643 | else | ||
644 | stack_base = vma->vm_end + stack_expand; | ||
632 | #else | 645 | #else |
633 | stack_base = vma->vm_start - EXTRA_STACK_VM_PAGES * PAGE_SIZE; | 646 | if (stack_size + stack_expand > rlim_stack) |
647 | stack_base = vma->vm_end - rlim_stack; | ||
648 | else | ||
649 | stack_base = vma->vm_start - stack_expand; | ||
634 | #endif | 650 | #endif |
635 | ret = expand_stack(vma, stack_base); | 651 | ret = expand_stack(vma, stack_base); |
636 | if (ret) | 652 | if (ret) |
@@ -941,9 +957,7 @@ void set_task_comm(struct task_struct *tsk, char *buf) | |||
941 | 957 | ||
942 | int flush_old_exec(struct linux_binprm * bprm) | 958 | int flush_old_exec(struct linux_binprm * bprm) |
943 | { | 959 | { |
944 | char * name; | 960 | int retval; |
945 | int i, ch, retval; | ||
946 | char tcomm[sizeof(current->comm)]; | ||
947 | 961 | ||
948 | /* | 962 | /* |
949 | * Make sure we have a private signal table and that | 963 | * Make sure we have a private signal table and that |
@@ -964,6 +978,25 @@ int flush_old_exec(struct linux_binprm * bprm) | |||
964 | 978 | ||
965 | bprm->mm = NULL; /* We're using it now */ | 979 | bprm->mm = NULL; /* We're using it now */ |
966 | 980 | ||
981 | current->flags &= ~PF_RANDOMIZE; | ||
982 | flush_thread(); | ||
983 | current->personality &= ~bprm->per_clear; | ||
984 | |||
985 | return 0; | ||
986 | |||
987 | out: | ||
988 | return retval; | ||
989 | } | ||
990 | EXPORT_SYMBOL(flush_old_exec); | ||
991 | |||
992 | void setup_new_exec(struct linux_binprm * bprm) | ||
993 | { | ||
994 | int i, ch; | ||
995 | char * name; | ||
996 | char tcomm[sizeof(current->comm)]; | ||
997 | |||
998 | arch_pick_mmap_layout(current->mm); | ||
999 | |||
967 | /* This is the point of no return */ | 1000 | /* This is the point of no return */ |
968 | current->sas_ss_sp = current->sas_ss_size = 0; | 1001 | current->sas_ss_sp = current->sas_ss_size = 0; |
969 | 1002 | ||
@@ -985,9 +1018,6 @@ int flush_old_exec(struct linux_binprm * bprm) | |||
985 | tcomm[i] = '\0'; | 1018 | tcomm[i] = '\0'; |
986 | set_task_comm(current, tcomm); | 1019 | set_task_comm(current, tcomm); |
987 | 1020 | ||
988 | current->flags &= ~PF_RANDOMIZE; | ||
989 | flush_thread(); | ||
990 | |||
991 | /* Set the new mm task size. We have to do that late because it may | 1021 | /* Set the new mm task size. We have to do that late because it may |
992 | * depend on TIF_32BIT which is only updated in flush_thread() on | 1022 | * depend on TIF_32BIT which is only updated in flush_thread() on |
993 | * some architectures like powerpc | 1023 | * some architectures like powerpc |
@@ -1003,8 +1033,6 @@ int flush_old_exec(struct linux_binprm * bprm) | |||
1003 | set_dumpable(current->mm, suid_dumpable); | 1033 | set_dumpable(current->mm, suid_dumpable); |
1004 | } | 1034 | } |
1005 | 1035 | ||
1006 | current->personality &= ~bprm->per_clear; | ||
1007 | |||
1008 | /* | 1036 | /* |
1009 | * Flush performance counters when crossing a | 1037 | * Flush performance counters when crossing a |
1010 | * security domain: | 1038 | * security domain: |
@@ -1019,14 +1047,8 @@ int flush_old_exec(struct linux_binprm * bprm) | |||
1019 | 1047 | ||
1020 | flush_signal_handlers(current, 0); | 1048 | flush_signal_handlers(current, 0); |
1021 | flush_old_files(current->files); | 1049 | flush_old_files(current->files); |
1022 | |||
1023 | return 0; | ||
1024 | |||
1025 | out: | ||
1026 | return retval; | ||
1027 | } | 1050 | } |
1028 | 1051 | EXPORT_SYMBOL(setup_new_exec); | |
1029 | EXPORT_SYMBOL(flush_old_exec); | ||
1030 | 1052 | ||
1031 | /* | 1053 | /* |
1032 | * Prepare credentials and lock ->cred_guard_mutex. | 1054 | * Prepare credentials and lock ->cred_guard_mutex. |
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h index af7b62699ea9..874d169a193e 100644 --- a/fs/ext4/ext4.h +++ b/fs/ext4/ext4.h | |||
@@ -361,14 +361,11 @@ struct ext4_new_group_data { | |||
361 | so set the magic i_delalloc_reserve_flag after taking the | 361 | so set the magic i_delalloc_reserve_flag after taking the |
362 | inode allocation semaphore for */ | 362 | inode allocation semaphore for */ |
363 | #define EXT4_GET_BLOCKS_DELALLOC_RESERVE 0x0004 | 363 | #define EXT4_GET_BLOCKS_DELALLOC_RESERVE 0x0004 |
364 | /* Call ext4_da_update_reserve_space() after successfully | ||
365 | allocating the blocks */ | ||
366 | #define EXT4_GET_BLOCKS_UPDATE_RESERVE_SPACE 0x0008 | ||
367 | /* caller is from the direct IO path, request to creation of an | 364 | /* caller is from the direct IO path, request to creation of an |
368 | unitialized extents if not allocated, split the uninitialized | 365 | unitialized extents if not allocated, split the uninitialized |
369 | extent if blocks has been preallocated already*/ | 366 | extent if blocks has been preallocated already*/ |
370 | #define EXT4_GET_BLOCKS_DIO 0x0010 | 367 | #define EXT4_GET_BLOCKS_DIO 0x0008 |
371 | #define EXT4_GET_BLOCKS_CONVERT 0x0020 | 368 | #define EXT4_GET_BLOCKS_CONVERT 0x0010 |
372 | #define EXT4_GET_BLOCKS_DIO_CREATE_EXT (EXT4_GET_BLOCKS_DIO|\ | 369 | #define EXT4_GET_BLOCKS_DIO_CREATE_EXT (EXT4_GET_BLOCKS_DIO|\ |
373 | EXT4_GET_BLOCKS_CREATE_UNINIT_EXT) | 370 | EXT4_GET_BLOCKS_CREATE_UNINIT_EXT) |
374 | /* Convert extent to initialized after direct IO complete */ | 371 | /* Convert extent to initialized after direct IO complete */ |
@@ -1443,6 +1440,8 @@ extern int ext4_block_truncate_page(handle_t *handle, | |||
1443 | extern int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf); | 1440 | extern int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf); |
1444 | extern qsize_t *ext4_get_reserved_space(struct inode *inode); | 1441 | extern qsize_t *ext4_get_reserved_space(struct inode *inode); |
1445 | extern int flush_aio_dio_completed_IO(struct inode *inode); | 1442 | extern int flush_aio_dio_completed_IO(struct inode *inode); |
1443 | extern void ext4_da_update_reserve_space(struct inode *inode, | ||
1444 | int used, int quota_claim); | ||
1446 | /* ioctl.c */ | 1445 | /* ioctl.c */ |
1447 | extern long ext4_ioctl(struct file *, unsigned int, unsigned long); | 1446 | extern long ext4_ioctl(struct file *, unsigned int, unsigned long); |
1448 | extern long ext4_compat_ioctl(struct file *, unsigned int, unsigned long); | 1447 | extern long ext4_compat_ioctl(struct file *, unsigned int, unsigned long); |
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c index 7d7b74e94687..765a4826b118 100644 --- a/fs/ext4/extents.c +++ b/fs/ext4/extents.c | |||
@@ -3132,7 +3132,19 @@ out: | |||
3132 | unmap_underlying_metadata_blocks(inode->i_sb->s_bdev, | 3132 | unmap_underlying_metadata_blocks(inode->i_sb->s_bdev, |
3133 | newblock + max_blocks, | 3133 | newblock + max_blocks, |
3134 | allocated - max_blocks); | 3134 | allocated - max_blocks); |
3135 | allocated = max_blocks; | ||
3135 | } | 3136 | } |
3137 | |||
3138 | /* | ||
3139 | * If we have done fallocate with the offset that is already | ||
3140 | * delayed allocated, we would have block reservation | ||
3141 | * and quota reservation done in the delayed write path. | ||
3142 | * But fallocate would have already updated quota and block | ||
3143 | * count for this offset. So cancel these reservation | ||
3144 | */ | ||
3145 | if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) | ||
3146 | ext4_da_update_reserve_space(inode, allocated, 0); | ||
3147 | |||
3136 | map_out: | 3148 | map_out: |
3137 | set_buffer_mapped(bh_result); | 3149 | set_buffer_mapped(bh_result); |
3138 | out1: | 3150 | out1: |
@@ -3368,9 +3380,18 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode, | |||
3368 | /* previous routine could use block we allocated */ | 3380 | /* previous routine could use block we allocated */ |
3369 | newblock = ext_pblock(&newex); | 3381 | newblock = ext_pblock(&newex); |
3370 | allocated = ext4_ext_get_actual_len(&newex); | 3382 | allocated = ext4_ext_get_actual_len(&newex); |
3383 | if (allocated > max_blocks) | ||
3384 | allocated = max_blocks; | ||
3371 | set_buffer_new(bh_result); | 3385 | set_buffer_new(bh_result); |
3372 | 3386 | ||
3373 | /* | 3387 | /* |
3388 | * Update reserved blocks/metadata blocks after successful | ||
3389 | * block allocation which had been deferred till now. | ||
3390 | */ | ||
3391 | if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) | ||
3392 | ext4_da_update_reserve_space(inode, allocated, 1); | ||
3393 | |||
3394 | /* | ||
3374 | * Cache the extent and update transaction to commit on fdatasync only | 3395 | * Cache the extent and update transaction to commit on fdatasync only |
3375 | * when it is _not_ an uninitialized extent. | 3396 | * when it is _not_ an uninitialized extent. |
3376 | */ | 3397 | */ |
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c index c818972c8302..e11952404e02 100644 --- a/fs/ext4/inode.c +++ b/fs/ext4/inode.c | |||
@@ -1053,11 +1053,12 @@ static int ext4_calc_metadata_amount(struct inode *inode, sector_t lblock) | |||
1053 | * Called with i_data_sem down, which is important since we can call | 1053 | * Called with i_data_sem down, which is important since we can call |
1054 | * ext4_discard_preallocations() from here. | 1054 | * ext4_discard_preallocations() from here. |
1055 | */ | 1055 | */ |
1056 | static void ext4_da_update_reserve_space(struct inode *inode, int used) | 1056 | void ext4_da_update_reserve_space(struct inode *inode, |
1057 | int used, int quota_claim) | ||
1057 | { | 1058 | { |
1058 | struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); | 1059 | struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); |
1059 | struct ext4_inode_info *ei = EXT4_I(inode); | 1060 | struct ext4_inode_info *ei = EXT4_I(inode); |
1060 | int mdb_free = 0; | 1061 | int mdb_free = 0, allocated_meta_blocks = 0; |
1061 | 1062 | ||
1062 | spin_lock(&ei->i_block_reservation_lock); | 1063 | spin_lock(&ei->i_block_reservation_lock); |
1063 | if (unlikely(used > ei->i_reserved_data_blocks)) { | 1064 | if (unlikely(used > ei->i_reserved_data_blocks)) { |
@@ -1073,6 +1074,7 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used) | |||
1073 | ei->i_reserved_data_blocks -= used; | 1074 | ei->i_reserved_data_blocks -= used; |
1074 | used += ei->i_allocated_meta_blocks; | 1075 | used += ei->i_allocated_meta_blocks; |
1075 | ei->i_reserved_meta_blocks -= ei->i_allocated_meta_blocks; | 1076 | ei->i_reserved_meta_blocks -= ei->i_allocated_meta_blocks; |
1077 | allocated_meta_blocks = ei->i_allocated_meta_blocks; | ||
1076 | ei->i_allocated_meta_blocks = 0; | 1078 | ei->i_allocated_meta_blocks = 0; |
1077 | percpu_counter_sub(&sbi->s_dirtyblocks_counter, used); | 1079 | percpu_counter_sub(&sbi->s_dirtyblocks_counter, used); |
1078 | 1080 | ||
@@ -1090,9 +1092,23 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used) | |||
1090 | spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); | 1092 | spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); |
1091 | 1093 | ||
1092 | /* Update quota subsystem */ | 1094 | /* Update quota subsystem */ |
1093 | vfs_dq_claim_block(inode, used); | 1095 | if (quota_claim) { |
1094 | if (mdb_free) | 1096 | vfs_dq_claim_block(inode, used); |
1095 | vfs_dq_release_reservation_block(inode, mdb_free); | 1097 | if (mdb_free) |
1098 | vfs_dq_release_reservation_block(inode, mdb_free); | ||
1099 | } else { | ||
1100 | /* | ||
1101 | * We did fallocate with an offset that is already delayed | ||
1102 | * allocated. So on delayed allocated writeback we should | ||
1103 | * not update the quota for allocated blocks. But then | ||
1104 | * converting an fallocate region to initialized region would | ||
1105 | * have caused a metadata allocation. So claim quota for | ||
1106 | * that | ||
1107 | */ | ||
1108 | if (allocated_meta_blocks) | ||
1109 | vfs_dq_claim_block(inode, allocated_meta_blocks); | ||
1110 | vfs_dq_release_reservation_block(inode, mdb_free + used); | ||
1111 | } | ||
1096 | 1112 | ||
1097 | /* | 1113 | /* |
1098 | * If we have done all the pending block allocations and if | 1114 | * If we have done all the pending block allocations and if |
@@ -1292,18 +1308,20 @@ int ext4_get_blocks(handle_t *handle, struct inode *inode, sector_t block, | |||
1292 | */ | 1308 | */ |
1293 | EXT4_I(inode)->i_state &= ~EXT4_STATE_EXT_MIGRATE; | 1309 | EXT4_I(inode)->i_state &= ~EXT4_STATE_EXT_MIGRATE; |
1294 | } | 1310 | } |
1295 | } | ||
1296 | 1311 | ||
1312 | /* | ||
1313 | * Update reserved blocks/metadata blocks after successful | ||
1314 | * block allocation which had been deferred till now. We don't | ||
1315 | * support fallocate for non extent files. So we can update | ||
1316 | * reserve space here. | ||
1317 | */ | ||
1318 | if ((retval > 0) && | ||
1319 | (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)) | ||
1320 | ext4_da_update_reserve_space(inode, retval, 1); | ||
1321 | } | ||
1297 | if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) | 1322 | if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) |
1298 | EXT4_I(inode)->i_delalloc_reserved_flag = 0; | 1323 | EXT4_I(inode)->i_delalloc_reserved_flag = 0; |
1299 | 1324 | ||
1300 | /* | ||
1301 | * Update reserved blocks/metadata blocks after successful | ||
1302 | * block allocation which had been deferred till now. | ||
1303 | */ | ||
1304 | if ((retval > 0) && (flags & EXT4_GET_BLOCKS_UPDATE_RESERVE_SPACE)) | ||
1305 | ext4_da_update_reserve_space(inode, retval); | ||
1306 | |||
1307 | up_write((&EXT4_I(inode)->i_data_sem)); | 1325 | up_write((&EXT4_I(inode)->i_data_sem)); |
1308 | if (retval > 0 && buffer_mapped(bh)) { | 1326 | if (retval > 0 && buffer_mapped(bh)) { |
1309 | int ret = check_block_validity(inode, "file system " | 1327 | int ret = check_block_validity(inode, "file system " |
@@ -1835,24 +1853,12 @@ repeat: | |||
1835 | * later. Real quota accounting is done at pages writeout | 1853 | * later. Real quota accounting is done at pages writeout |
1836 | * time. | 1854 | * time. |
1837 | */ | 1855 | */ |
1838 | if (vfs_dq_reserve_block(inode, md_needed + 1)) { | 1856 | if (vfs_dq_reserve_block(inode, md_needed + 1)) |
1839 | /* | ||
1840 | * We tend to badly over-estimate the amount of | ||
1841 | * metadata blocks which are needed, so if we have | ||
1842 | * reserved any metadata blocks, try to force out the | ||
1843 | * inode and see if we have any better luck. | ||
1844 | */ | ||
1845 | if (md_reserved && retries++ <= 3) | ||
1846 | goto retry; | ||
1847 | return -EDQUOT; | 1857 | return -EDQUOT; |
1848 | } | ||
1849 | 1858 | ||
1850 | if (ext4_claim_free_blocks(sbi, md_needed + 1)) { | 1859 | if (ext4_claim_free_blocks(sbi, md_needed + 1)) { |
1851 | vfs_dq_release_reservation_block(inode, md_needed + 1); | 1860 | vfs_dq_release_reservation_block(inode, md_needed + 1); |
1852 | if (ext4_should_retry_alloc(inode->i_sb, &retries)) { | 1861 | if (ext4_should_retry_alloc(inode->i_sb, &retries)) { |
1853 | retry: | ||
1854 | if (md_reserved) | ||
1855 | write_inode_now(inode, (retries == 3)); | ||
1856 | yield(); | 1862 | yield(); |
1857 | goto repeat; | 1863 | goto repeat; |
1858 | } | 1864 | } |
@@ -2213,10 +2219,10 @@ static int mpage_da_map_blocks(struct mpage_da_data *mpd) | |||
2213 | * variables are updated after the blocks have been allocated. | 2219 | * variables are updated after the blocks have been allocated. |
2214 | */ | 2220 | */ |
2215 | new.b_state = 0; | 2221 | new.b_state = 0; |
2216 | get_blocks_flags = (EXT4_GET_BLOCKS_CREATE | | 2222 | get_blocks_flags = EXT4_GET_BLOCKS_CREATE; |
2217 | EXT4_GET_BLOCKS_DELALLOC_RESERVE); | ||
2218 | if (mpd->b_state & (1 << BH_Delay)) | 2223 | if (mpd->b_state & (1 << BH_Delay)) |
2219 | get_blocks_flags |= EXT4_GET_BLOCKS_UPDATE_RESERVE_SPACE; | 2224 | get_blocks_flags |= EXT4_GET_BLOCKS_DELALLOC_RESERVE; |
2225 | |||
2220 | blks = ext4_get_blocks(handle, mpd->inode, next, max_blocks, | 2226 | blks = ext4_get_blocks(handle, mpd->inode, next, max_blocks, |
2221 | &new, get_blocks_flags); | 2227 | &new, get_blocks_flags); |
2222 | if (blks < 0) { | 2228 | if (blks < 0) { |
@@ -3032,7 +3038,7 @@ static int ext4_da_write_begin(struct file *file, struct address_space *mapping, | |||
3032 | loff_t pos, unsigned len, unsigned flags, | 3038 | loff_t pos, unsigned len, unsigned flags, |
3033 | struct page **pagep, void **fsdata) | 3039 | struct page **pagep, void **fsdata) |
3034 | { | 3040 | { |
3035 | int ret, retries = 0; | 3041 | int ret, retries = 0, quota_retries = 0; |
3036 | struct page *page; | 3042 | struct page *page; |
3037 | pgoff_t index; | 3043 | pgoff_t index; |
3038 | unsigned from, to; | 3044 | unsigned from, to; |
@@ -3091,6 +3097,22 @@ retry: | |||
3091 | 3097 | ||
3092 | if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) | 3098 | if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) |
3093 | goto retry; | 3099 | goto retry; |
3100 | |||
3101 | if ((ret == -EDQUOT) && | ||
3102 | EXT4_I(inode)->i_reserved_meta_blocks && | ||
3103 | (quota_retries++ < 3)) { | ||
3104 | /* | ||
3105 | * Since we often over-estimate the number of meta | ||
3106 | * data blocks required, we may sometimes get a | ||
3107 | * spurios out of quota error even though there would | ||
3108 | * be enough space once we write the data blocks and | ||
3109 | * find out how many meta data blocks were _really_ | ||
3110 | * required. So try forcing the inode write to see if | ||
3111 | * that helps. | ||
3112 | */ | ||
3113 | write_inode_now(inode, (quota_retries == 3)); | ||
3114 | goto retry; | ||
3115 | } | ||
3094 | out: | 3116 | out: |
3095 | return ret; | 3117 | return ret; |
3096 | } | 3118 | } |
diff --git a/fs/fcntl.c b/fs/fcntl.c index 2cf93ec40a67..97e01dc0d95f 100644 --- a/fs/fcntl.c +++ b/fs/fcntl.c | |||
@@ -618,60 +618,90 @@ static DEFINE_RWLOCK(fasync_lock); | |||
618 | static struct kmem_cache *fasync_cache __read_mostly; | 618 | static struct kmem_cache *fasync_cache __read_mostly; |
619 | 619 | ||
620 | /* | 620 | /* |
621 | * fasync_helper() is used by almost all character device drivers | 621 | * Remove a fasync entry. If successfully removed, return |
622 | * to set up the fasync queue. It returns negative on error, 0 if it did | 622 | * positive and clear the FASYNC flag. If no entry exists, |
623 | * no changes and positive if it added/deleted the entry. | 623 | * do nothing and return 0. |
624 | * | ||
625 | * NOTE! It is very important that the FASYNC flag always | ||
626 | * match the state "is the filp on a fasync list". | ||
627 | * | ||
628 | * We always take the 'filp->f_lock', in since fasync_lock | ||
629 | * needs to be irq-safe. | ||
624 | */ | 630 | */ |
625 | int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp) | 631 | static int fasync_remove_entry(struct file *filp, struct fasync_struct **fapp) |
626 | { | 632 | { |
627 | struct fasync_struct *fa, **fp; | 633 | struct fasync_struct *fa, **fp; |
628 | struct fasync_struct *new = NULL; | ||
629 | int result = 0; | 634 | int result = 0; |
630 | 635 | ||
631 | if (on) { | 636 | spin_lock(&filp->f_lock); |
632 | new = kmem_cache_alloc(fasync_cache, GFP_KERNEL); | 637 | write_lock_irq(&fasync_lock); |
633 | if (!new) | 638 | for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) { |
634 | return -ENOMEM; | 639 | if (fa->fa_file != filp) |
640 | continue; | ||
641 | *fp = fa->fa_next; | ||
642 | kmem_cache_free(fasync_cache, fa); | ||
643 | filp->f_flags &= ~FASYNC; | ||
644 | result = 1; | ||
645 | break; | ||
635 | } | 646 | } |
647 | write_unlock_irq(&fasync_lock); | ||
648 | spin_unlock(&filp->f_lock); | ||
649 | return result; | ||
650 | } | ||
651 | |||
652 | /* | ||
653 | * Add a fasync entry. Return negative on error, positive if | ||
654 | * added, and zero if did nothing but change an existing one. | ||
655 | * | ||
656 | * NOTE! It is very important that the FASYNC flag always | ||
657 | * match the state "is the filp on a fasync list". | ||
658 | */ | ||
659 | static int fasync_add_entry(int fd, struct file *filp, struct fasync_struct **fapp) | ||
660 | { | ||
661 | struct fasync_struct *new, *fa, **fp; | ||
662 | int result = 0; | ||
663 | |||
664 | new = kmem_cache_alloc(fasync_cache, GFP_KERNEL); | ||
665 | if (!new) | ||
666 | return -ENOMEM; | ||
636 | 667 | ||
637 | /* | ||
638 | * We need to take f_lock first since it's not an IRQ-safe | ||
639 | * lock. | ||
640 | */ | ||
641 | spin_lock(&filp->f_lock); | 668 | spin_lock(&filp->f_lock); |
642 | write_lock_irq(&fasync_lock); | 669 | write_lock_irq(&fasync_lock); |
643 | for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) { | 670 | for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) { |
644 | if (fa->fa_file == filp) { | 671 | if (fa->fa_file != filp) |
645 | if(on) { | 672 | continue; |
646 | fa->fa_fd = fd; | 673 | fa->fa_fd = fd; |
647 | kmem_cache_free(fasync_cache, new); | 674 | kmem_cache_free(fasync_cache, new); |
648 | } else { | 675 | goto out; |
649 | *fp = fa->fa_next; | ||
650 | kmem_cache_free(fasync_cache, fa); | ||
651 | result = 1; | ||
652 | } | ||
653 | goto out; | ||
654 | } | ||
655 | } | 676 | } |
656 | 677 | ||
657 | if (on) { | 678 | new->magic = FASYNC_MAGIC; |
658 | new->magic = FASYNC_MAGIC; | 679 | new->fa_file = filp; |
659 | new->fa_file = filp; | 680 | new->fa_fd = fd; |
660 | new->fa_fd = fd; | 681 | new->fa_next = *fapp; |
661 | new->fa_next = *fapp; | 682 | *fapp = new; |
662 | *fapp = new; | 683 | result = 1; |
663 | result = 1; | 684 | filp->f_flags |= FASYNC; |
664 | } | 685 | |
665 | out: | 686 | out: |
666 | if (on) | ||
667 | filp->f_flags |= FASYNC; | ||
668 | else | ||
669 | filp->f_flags &= ~FASYNC; | ||
670 | write_unlock_irq(&fasync_lock); | 687 | write_unlock_irq(&fasync_lock); |
671 | spin_unlock(&filp->f_lock); | 688 | spin_unlock(&filp->f_lock); |
672 | return result; | 689 | return result; |
673 | } | 690 | } |
674 | 691 | ||
692 | /* | ||
693 | * fasync_helper() is used by almost all character device drivers | ||
694 | * to set up the fasync queue, and for regular files by the file | ||
695 | * lease code. It returns negative on error, 0 if it did no changes | ||
696 | * and positive if it added/deleted the entry. | ||
697 | */ | ||
698 | int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp) | ||
699 | { | ||
700 | if (!on) | ||
701 | return fasync_remove_entry(filp, fapp); | ||
702 | return fasync_add_entry(fd, filp, fapp); | ||
703 | } | ||
704 | |||
675 | EXPORT_SYMBOL(fasync_helper); | 705 | EXPORT_SYMBOL(fasync_helper); |
676 | 706 | ||
677 | void __kill_fasync(struct fasync_struct *fa, int sig, int band) | 707 | void __kill_fasync(struct fasync_struct *fa, int sig, int band) |
diff --git a/fs/file_table.c b/fs/file_table.c index 69652c5bd5f0..b98404b54383 100644 --- a/fs/file_table.c +++ b/fs/file_table.c | |||
@@ -253,6 +253,7 @@ void __fput(struct file *file) | |||
253 | if (file->f_op && file->f_op->release) | 253 | if (file->f_op && file->f_op->release) |
254 | file->f_op->release(inode, file); | 254 | file->f_op->release(inode, file); |
255 | security_file_free(file); | 255 | security_file_free(file); |
256 | ima_file_free(file); | ||
256 | if (unlikely(S_ISCHR(inode->i_mode) && inode->i_cdev != NULL)) | 257 | if (unlikely(S_ISCHR(inode->i_mode) && inode->i_cdev != NULL)) |
257 | cdev_put(inode->i_cdev); | 258 | cdev_put(inode->i_cdev); |
258 | fops_put(file->f_op); | 259 | fops_put(file->f_op); |
diff --git a/fs/fuse/file.c b/fs/fuse/file.c index c18913a777ae..a9f5e137f1d3 100644 --- a/fs/fuse/file.c +++ b/fs/fuse/file.c | |||
@@ -828,6 +828,9 @@ static ssize_t fuse_fill_write_pages(struct fuse_req *req, | |||
828 | if (!page) | 828 | if (!page) |
829 | break; | 829 | break; |
830 | 830 | ||
831 | if (mapping_writably_mapped(mapping)) | ||
832 | flush_dcache_page(page); | ||
833 | |||
831 | pagefault_disable(); | 834 | pagefault_disable(); |
832 | tmp = iov_iter_copy_from_user_atomic(page, ii, offset, bytes); | 835 | tmp = iov_iter_copy_from_user_atomic(page, ii, offset, bytes); |
833 | pagefault_enable(); | 836 | pagefault_enable(); |
diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c index 6d47379e794b..583e823307ae 100644 --- a/fs/gfs2/bmap.c +++ b/fs/gfs2/bmap.c | |||
@@ -541,7 +541,7 @@ static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock, | |||
541 | *ptr++ = cpu_to_be64(bn++); | 541 | *ptr++ = cpu_to_be64(bn++); |
542 | break; | 542 | break; |
543 | } | 543 | } |
544 | } while (state != ALLOC_DATA); | 544 | } while ((state != ALLOC_DATA) || !dblock); |
545 | 545 | ||
546 | ip->i_height = height; | 546 | ip->i_height = height; |
547 | gfs2_add_inode_blocks(&ip->i_inode, alloced); | 547 | gfs2_add_inode_blocks(&ip->i_inode, alloced); |
diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c index f455a03a09e2..f42663325931 100644 --- a/fs/gfs2/glock.c +++ b/fs/gfs2/glock.c | |||
@@ -769,6 +769,7 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, | |||
769 | if (!gl) | 769 | if (!gl) |
770 | return -ENOMEM; | 770 | return -ENOMEM; |
771 | 771 | ||
772 | atomic_inc(&sdp->sd_glock_disposal); | ||
772 | gl->gl_flags = 0; | 773 | gl->gl_flags = 0; |
773 | gl->gl_name = name; | 774 | gl->gl_name = name; |
774 | atomic_set(&gl->gl_ref, 1); | 775 | atomic_set(&gl->gl_ref, 1); |
@@ -1538,6 +1539,9 @@ void gfs2_gl_hash_clear(struct gfs2_sbd *sdp) | |||
1538 | up_write(&gfs2_umount_flush_sem); | 1539 | up_write(&gfs2_umount_flush_sem); |
1539 | msleep(10); | 1540 | msleep(10); |
1540 | } | 1541 | } |
1542 | flush_workqueue(glock_workqueue); | ||
1543 | wait_event(sdp->sd_glock_wait, atomic_read(&sdp->sd_glock_disposal) == 0); | ||
1544 | gfs2_dump_lockstate(sdp); | ||
1541 | } | 1545 | } |
1542 | 1546 | ||
1543 | void gfs2_glock_finish_truncate(struct gfs2_inode *ip) | 1547 | void gfs2_glock_finish_truncate(struct gfs2_inode *ip) |
diff --git a/fs/gfs2/glock.h b/fs/gfs2/glock.h index 13f0bd228132..c0262faf4725 100644 --- a/fs/gfs2/glock.h +++ b/fs/gfs2/glock.h | |||
@@ -123,7 +123,7 @@ struct lm_lockops { | |||
123 | int (*lm_mount) (struct gfs2_sbd *sdp, const char *fsname); | 123 | int (*lm_mount) (struct gfs2_sbd *sdp, const char *fsname); |
124 | void (*lm_unmount) (struct gfs2_sbd *sdp); | 124 | void (*lm_unmount) (struct gfs2_sbd *sdp); |
125 | void (*lm_withdraw) (struct gfs2_sbd *sdp); | 125 | void (*lm_withdraw) (struct gfs2_sbd *sdp); |
126 | void (*lm_put_lock) (struct kmem_cache *cachep, void *gl); | 126 | void (*lm_put_lock) (struct kmem_cache *cachep, struct gfs2_glock *gl); |
127 | unsigned int (*lm_lock) (struct gfs2_glock *gl, | 127 | unsigned int (*lm_lock) (struct gfs2_glock *gl, |
128 | unsigned int req_state, unsigned int flags); | 128 | unsigned int req_state, unsigned int flags); |
129 | void (*lm_cancel) (struct gfs2_glock *gl); | 129 | void (*lm_cancel) (struct gfs2_glock *gl); |
diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h index 4792200978c8..bc0ad158e6b4 100644 --- a/fs/gfs2/incore.h +++ b/fs/gfs2/incore.h | |||
@@ -544,6 +544,8 @@ struct gfs2_sbd { | |||
544 | struct gfs2_holder sd_live_gh; | 544 | struct gfs2_holder sd_live_gh; |
545 | struct gfs2_glock *sd_rename_gl; | 545 | struct gfs2_glock *sd_rename_gl; |
546 | struct gfs2_glock *sd_trans_gl; | 546 | struct gfs2_glock *sd_trans_gl; |
547 | wait_queue_head_t sd_glock_wait; | ||
548 | atomic_t sd_glock_disposal; | ||
547 | 549 | ||
548 | /* Inode Stuff */ | 550 | /* Inode Stuff */ |
549 | 551 | ||
diff --git a/fs/gfs2/lock_dlm.c b/fs/gfs2/lock_dlm.c index 46df988323bc..0e5e0e7022e5 100644 --- a/fs/gfs2/lock_dlm.c +++ b/fs/gfs2/lock_dlm.c | |||
@@ -21,6 +21,7 @@ static void gdlm_ast(void *arg) | |||
21 | { | 21 | { |
22 | struct gfs2_glock *gl = arg; | 22 | struct gfs2_glock *gl = arg; |
23 | unsigned ret = gl->gl_state; | 23 | unsigned ret = gl->gl_state; |
24 | struct gfs2_sbd *sdp = gl->gl_sbd; | ||
24 | 25 | ||
25 | BUG_ON(gl->gl_lksb.sb_flags & DLM_SBF_DEMOTED); | 26 | BUG_ON(gl->gl_lksb.sb_flags & DLM_SBF_DEMOTED); |
26 | 27 | ||
@@ -30,6 +31,8 @@ static void gdlm_ast(void *arg) | |||
30 | switch (gl->gl_lksb.sb_status) { | 31 | switch (gl->gl_lksb.sb_status) { |
31 | case -DLM_EUNLOCK: /* Unlocked, so glock can be freed */ | 32 | case -DLM_EUNLOCK: /* Unlocked, so glock can be freed */ |
32 | kmem_cache_free(gfs2_glock_cachep, gl); | 33 | kmem_cache_free(gfs2_glock_cachep, gl); |
34 | if (atomic_dec_and_test(&sdp->sd_glock_disposal)) | ||
35 | wake_up(&sdp->sd_glock_wait); | ||
33 | return; | 36 | return; |
34 | case -DLM_ECANCEL: /* Cancel while getting lock */ | 37 | case -DLM_ECANCEL: /* Cancel while getting lock */ |
35 | ret |= LM_OUT_CANCELED; | 38 | ret |= LM_OUT_CANCELED; |
@@ -164,14 +167,16 @@ static unsigned int gdlm_lock(struct gfs2_glock *gl, | |||
164 | return LM_OUT_ASYNC; | 167 | return LM_OUT_ASYNC; |
165 | } | 168 | } |
166 | 169 | ||
167 | static void gdlm_put_lock(struct kmem_cache *cachep, void *ptr) | 170 | static void gdlm_put_lock(struct kmem_cache *cachep, struct gfs2_glock *gl) |
168 | { | 171 | { |
169 | struct gfs2_glock *gl = ptr; | 172 | struct gfs2_sbd *sdp = gl->gl_sbd; |
170 | struct lm_lockstruct *ls = &gl->gl_sbd->sd_lockstruct; | 173 | struct lm_lockstruct *ls = &sdp->sd_lockstruct; |
171 | int error; | 174 | int error; |
172 | 175 | ||
173 | if (gl->gl_lksb.sb_lkid == 0) { | 176 | if (gl->gl_lksb.sb_lkid == 0) { |
174 | kmem_cache_free(cachep, gl); | 177 | kmem_cache_free(cachep, gl); |
178 | if (atomic_dec_and_test(&sdp->sd_glock_disposal)) | ||
179 | wake_up(&sdp->sd_glock_wait); | ||
175 | return; | 180 | return; |
176 | } | 181 | } |
177 | 182 | ||
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c index edfee24f3636..a86ed6381566 100644 --- a/fs/gfs2/ops_fstype.c +++ b/fs/gfs2/ops_fstype.c | |||
@@ -82,6 +82,8 @@ static struct gfs2_sbd *init_sbd(struct super_block *sb) | |||
82 | 82 | ||
83 | gfs2_tune_init(&sdp->sd_tune); | 83 | gfs2_tune_init(&sdp->sd_tune); |
84 | 84 | ||
85 | init_waitqueue_head(&sdp->sd_glock_wait); | ||
86 | atomic_set(&sdp->sd_glock_disposal, 0); | ||
85 | spin_lock_init(&sdp->sd_statfs_spin); | 87 | spin_lock_init(&sdp->sd_statfs_spin); |
86 | 88 | ||
87 | spin_lock_init(&sdp->sd_rindex_spin); | 89 | spin_lock_init(&sdp->sd_rindex_spin); |
@@ -723,7 +725,7 @@ static int init_journal(struct gfs2_sbd *sdp, int undo) | |||
723 | goto fail; | 725 | goto fail; |
724 | } | 726 | } |
725 | 727 | ||
726 | error = -EINVAL; | 728 | error = -EUSERS; |
727 | if (!gfs2_jindex_size(sdp)) { | 729 | if (!gfs2_jindex_size(sdp)) { |
728 | fs_err(sdp, "no journals!\n"); | 730 | fs_err(sdp, "no journals!\n"); |
729 | goto fail_jindex; | 731 | goto fail_jindex; |
@@ -983,9 +985,17 @@ static const match_table_t nolock_tokens = { | |||
983 | { Opt_err, NULL }, | 985 | { Opt_err, NULL }, |
984 | }; | 986 | }; |
985 | 987 | ||
988 | static void nolock_put_lock(struct kmem_cache *cachep, struct gfs2_glock *gl) | ||
989 | { | ||
990 | struct gfs2_sbd *sdp = gl->gl_sbd; | ||
991 | kmem_cache_free(cachep, gl); | ||
992 | if (atomic_dec_and_test(&sdp->sd_glock_disposal)) | ||
993 | wake_up(&sdp->sd_glock_wait); | ||
994 | } | ||
995 | |||
986 | static const struct lm_lockops nolock_ops = { | 996 | static const struct lm_lockops nolock_ops = { |
987 | .lm_proto_name = "lock_nolock", | 997 | .lm_proto_name = "lock_nolock", |
988 | .lm_put_lock = kmem_cache_free, | 998 | .lm_put_lock = nolock_put_lock, |
989 | .lm_tokens = &nolock_tokens, | 999 | .lm_tokens = &nolock_tokens, |
990 | }; | 1000 | }; |
991 | 1001 | ||
diff --git a/fs/gfs2/ops_inode.c b/fs/gfs2/ops_inode.c index 78f73ca1ef3e..84350e1be66d 100644 --- a/fs/gfs2/ops_inode.c +++ b/fs/gfs2/ops_inode.c | |||
@@ -1088,7 +1088,8 @@ static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd) | |||
1088 | error = vfs_follow_link(nd, buf); | 1088 | error = vfs_follow_link(nd, buf); |
1089 | if (buf != array) | 1089 | if (buf != array) |
1090 | kfree(buf); | 1090 | kfree(buf); |
1091 | } | 1091 | } else |
1092 | path_put(&nd->path); | ||
1092 | 1093 | ||
1093 | return ERR_PTR(error); | 1094 | return ERR_PTR(error); |
1094 | } | 1095 | } |
diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c index 0608f490c295..503b842f3ba2 100644 --- a/fs/gfs2/rgrp.c +++ b/fs/gfs2/rgrp.c | |||
@@ -591,11 +591,7 @@ static int gfs2_ri_update(struct gfs2_inode *ip) | |||
591 | u64 rgrp_count = ip->i_disksize; | 591 | u64 rgrp_count = ip->i_disksize; |
592 | int error; | 592 | int error; |
593 | 593 | ||
594 | if (do_div(rgrp_count, sizeof(struct gfs2_rindex))) { | 594 | do_div(rgrp_count, sizeof(struct gfs2_rindex)); |
595 | gfs2_consist_inode(ip); | ||
596 | return -EIO; | ||
597 | } | ||
598 | |||
599 | clear_rgrpdi(sdp); | 595 | clear_rgrpdi(sdp); |
600 | 596 | ||
601 | file_ra_state_init(&ra_state, inode->i_mapping); | 597 | file_ra_state_init(&ra_state, inode->i_mapping); |
@@ -915,7 +911,7 @@ void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd) | |||
915 | struct gfs2_alloc *gfs2_alloc_get(struct gfs2_inode *ip) | 911 | struct gfs2_alloc *gfs2_alloc_get(struct gfs2_inode *ip) |
916 | { | 912 | { |
917 | BUG_ON(ip->i_alloc != NULL); | 913 | BUG_ON(ip->i_alloc != NULL); |
918 | ip->i_alloc = kzalloc(sizeof(struct gfs2_alloc), GFP_KERNEL); | 914 | ip->i_alloc = kzalloc(sizeof(struct gfs2_alloc), GFP_NOFS); |
919 | return ip->i_alloc; | 915 | return ip->i_alloc; |
920 | } | 916 | } |
921 | 917 | ||
diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c index c282ad41f3d1..b9dd3da22c0a 100644 --- a/fs/gfs2/super.c +++ b/fs/gfs2/super.c | |||
@@ -21,6 +21,7 @@ | |||
21 | #include <linux/gfs2_ondisk.h> | 21 | #include <linux/gfs2_ondisk.h> |
22 | #include <linux/crc32.h> | 22 | #include <linux/crc32.h> |
23 | #include <linux/time.h> | 23 | #include <linux/time.h> |
24 | #include <linux/wait.h> | ||
24 | 25 | ||
25 | #include "gfs2.h" | 26 | #include "gfs2.h" |
26 | #include "incore.h" | 27 | #include "incore.h" |
diff --git a/fs/hppfs/hppfs.c b/fs/hppfs/hppfs.c index a5089a6dd67a..7239efc690d8 100644 --- a/fs/hppfs/hppfs.c +++ b/fs/hppfs/hppfs.c | |||
@@ -646,22 +646,27 @@ static const struct super_operations hppfs_sbops = { | |||
646 | static int hppfs_readlink(struct dentry *dentry, char __user *buffer, | 646 | static int hppfs_readlink(struct dentry *dentry, char __user *buffer, |
647 | int buflen) | 647 | int buflen) |
648 | { | 648 | { |
649 | struct dentry *proc_dentry; | 649 | struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry; |
650 | |||
651 | proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry; | ||
652 | return proc_dentry->d_inode->i_op->readlink(proc_dentry, buffer, | 650 | return proc_dentry->d_inode->i_op->readlink(proc_dentry, buffer, |
653 | buflen); | 651 | buflen); |
654 | } | 652 | } |
655 | 653 | ||
656 | static void *hppfs_follow_link(struct dentry *dentry, struct nameidata *nd) | 654 | static void *hppfs_follow_link(struct dentry *dentry, struct nameidata *nd) |
657 | { | 655 | { |
658 | struct dentry *proc_dentry; | 656 | struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry; |
659 | |||
660 | proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry; | ||
661 | 657 | ||
662 | return proc_dentry->d_inode->i_op->follow_link(proc_dentry, nd); | 658 | return proc_dentry->d_inode->i_op->follow_link(proc_dentry, nd); |
663 | } | 659 | } |
664 | 660 | ||
661 | static void hppfs_put_link(struct dentry *dentry, struct nameidata *nd, | ||
662 | void *cookie) | ||
663 | { | ||
664 | struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry; | ||
665 | |||
666 | if (proc_dentry->d_inode->i_op->put_link) | ||
667 | proc_dentry->d_inode->i_op->put_link(proc_dentry, nd, cookie); | ||
668 | } | ||
669 | |||
665 | static const struct inode_operations hppfs_dir_iops = { | 670 | static const struct inode_operations hppfs_dir_iops = { |
666 | .lookup = hppfs_lookup, | 671 | .lookup = hppfs_lookup, |
667 | }; | 672 | }; |
@@ -669,6 +674,7 @@ static const struct inode_operations hppfs_dir_iops = { | |||
669 | static const struct inode_operations hppfs_link_iops = { | 674 | static const struct inode_operations hppfs_link_iops = { |
670 | .readlink = hppfs_readlink, | 675 | .readlink = hppfs_readlink, |
671 | .follow_link = hppfs_follow_link, | 676 | .follow_link = hppfs_follow_link, |
677 | .put_link = hppfs_put_link, | ||
672 | }; | 678 | }; |
673 | 679 | ||
674 | static struct inode *get_inode(struct super_block *sb, struct dentry *dentry) | 680 | static struct inode *get_inode(struct super_block *sb, struct dentry *dentry) |
diff --git a/fs/namei.c b/fs/namei.c index b55440baf7ab..a4855af776a8 100644 --- a/fs/namei.c +++ b/fs/namei.c | |||
@@ -561,6 +561,7 @@ static __always_inline int __do_follow_link(struct path *path, struct nameidata | |||
561 | dget(dentry); | 561 | dget(dentry); |
562 | } | 562 | } |
563 | mntget(path->mnt); | 563 | mntget(path->mnt); |
564 | nd->last_type = LAST_BIND; | ||
564 | cookie = dentry->d_inode->i_op->follow_link(dentry, nd); | 565 | cookie = dentry->d_inode->i_op->follow_link(dentry, nd); |
565 | error = PTR_ERR(cookie); | 566 | error = PTR_ERR(cookie); |
566 | if (!IS_ERR(cookie)) { | 567 | if (!IS_ERR(cookie)) { |
@@ -822,6 +823,17 @@ fail: | |||
822 | } | 823 | } |
823 | 824 | ||
824 | /* | 825 | /* |
826 | * This is a temporary kludge to deal with "automount" symlinks; proper | ||
827 | * solution is to trigger them on follow_mount(), so that do_lookup() | ||
828 | * would DTRT. To be killed before 2.6.34-final. | ||
829 | */ | ||
830 | static inline int follow_on_final(struct inode *inode, unsigned lookup_flags) | ||
831 | { | ||
832 | return inode && unlikely(inode->i_op->follow_link) && | ||
833 | ((lookup_flags & LOOKUP_FOLLOW) || S_ISDIR(inode->i_mode)); | ||
834 | } | ||
835 | |||
836 | /* | ||
825 | * Name resolution. | 837 | * Name resolution. |
826 | * This is the basic name resolution function, turning a pathname into | 838 | * This is the basic name resolution function, turning a pathname into |
827 | * the final dentry. We expect 'base' to be positive and a directory. | 839 | * the final dentry. We expect 'base' to be positive and a directory. |
@@ -941,8 +953,7 @@ last_component: | |||
941 | if (err) | 953 | if (err) |
942 | break; | 954 | break; |
943 | inode = next.dentry->d_inode; | 955 | inode = next.dentry->d_inode; |
944 | if ((lookup_flags & LOOKUP_FOLLOW) | 956 | if (follow_on_final(inode, lookup_flags)) { |
945 | && inode && inode->i_op->follow_link) { | ||
946 | err = do_follow_link(&next, nd); | 957 | err = do_follow_link(&next, nd); |
947 | if (err) | 958 | if (err) |
948 | goto return_err; | 959 | goto return_err; |
@@ -1603,11 +1614,12 @@ struct file *do_filp_open(int dfd, const char *pathname, | |||
1603 | struct file *filp; | 1614 | struct file *filp; |
1604 | struct nameidata nd; | 1615 | struct nameidata nd; |
1605 | int error; | 1616 | int error; |
1606 | struct path path, save; | 1617 | struct path path; |
1607 | struct dentry *dir; | 1618 | struct dentry *dir; |
1608 | int count = 0; | 1619 | int count = 0; |
1609 | int will_truncate; | 1620 | int will_truncate; |
1610 | int flag = open_to_namei_flags(open_flag); | 1621 | int flag = open_to_namei_flags(open_flag); |
1622 | int force_reval = 0; | ||
1611 | 1623 | ||
1612 | /* | 1624 | /* |
1613 | * O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only | 1625 | * O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only |
@@ -1619,7 +1631,7 @@ struct file *do_filp_open(int dfd, const char *pathname, | |||
1619 | open_flag |= O_DSYNC; | 1631 | open_flag |= O_DSYNC; |
1620 | 1632 | ||
1621 | if (!acc_mode) | 1633 | if (!acc_mode) |
1622 | acc_mode = MAY_OPEN | ACC_MODE(flag); | 1634 | acc_mode = MAY_OPEN | ACC_MODE(open_flag); |
1623 | 1635 | ||
1624 | /* O_TRUNC implies we need access checks for write permissions */ | 1636 | /* O_TRUNC implies we need access checks for write permissions */ |
1625 | if (flag & O_TRUNC) | 1637 | if (flag & O_TRUNC) |
@@ -1659,9 +1671,12 @@ struct file *do_filp_open(int dfd, const char *pathname, | |||
1659 | /* | 1671 | /* |
1660 | * Create - we need to know the parent. | 1672 | * Create - we need to know the parent. |
1661 | */ | 1673 | */ |
1674 | reval: | ||
1662 | error = path_init(dfd, pathname, LOOKUP_PARENT, &nd); | 1675 | error = path_init(dfd, pathname, LOOKUP_PARENT, &nd); |
1663 | if (error) | 1676 | if (error) |
1664 | return ERR_PTR(error); | 1677 | return ERR_PTR(error); |
1678 | if (force_reval) | ||
1679 | nd.flags |= LOOKUP_REVAL; | ||
1665 | error = path_walk(pathname, &nd); | 1680 | error = path_walk(pathname, &nd); |
1666 | if (error) { | 1681 | if (error) { |
1667 | if (nd.root.mnt) | 1682 | if (nd.root.mnt) |
@@ -1731,8 +1746,7 @@ do_last: | |||
1731 | if (nd.root.mnt) | 1746 | if (nd.root.mnt) |
1732 | path_put(&nd.root); | 1747 | path_put(&nd.root); |
1733 | if (!IS_ERR(filp)) { | 1748 | if (!IS_ERR(filp)) { |
1734 | error = ima_path_check(&filp->f_path, filp->f_mode & | 1749 | error = ima_file_check(filp, acc_mode); |
1735 | (MAY_READ | MAY_WRITE | MAY_EXEC)); | ||
1736 | if (error) { | 1750 | if (error) { |
1737 | fput(filp); | 1751 | fput(filp); |
1738 | filp = ERR_PTR(error); | 1752 | filp = ERR_PTR(error); |
@@ -1792,8 +1806,7 @@ ok: | |||
1792 | } | 1806 | } |
1793 | filp = nameidata_to_filp(&nd); | 1807 | filp = nameidata_to_filp(&nd); |
1794 | if (!IS_ERR(filp)) { | 1808 | if (!IS_ERR(filp)) { |
1795 | error = ima_path_check(&filp->f_path, filp->f_mode & | 1809 | error = ima_file_check(filp, acc_mode); |
1796 | (MAY_READ | MAY_WRITE | MAY_EXEC)); | ||
1797 | if (error) { | 1810 | if (error) { |
1798 | fput(filp); | 1811 | fput(filp); |
1799 | filp = ERR_PTR(error); | 1812 | filp = ERR_PTR(error); |
@@ -1853,17 +1866,7 @@ do_link: | |||
1853 | error = security_inode_follow_link(path.dentry, &nd); | 1866 | error = security_inode_follow_link(path.dentry, &nd); |
1854 | if (error) | 1867 | if (error) |
1855 | goto exit_dput; | 1868 | goto exit_dput; |
1856 | save = nd.path; | ||
1857 | path_get(&save); | ||
1858 | error = __do_follow_link(&path, &nd); | 1869 | error = __do_follow_link(&path, &nd); |
1859 | if (error == -ESTALE) { | ||
1860 | /* nd.path had been dropped */ | ||
1861 | nd.path = save; | ||
1862 | path_get(&nd.path); | ||
1863 | nd.flags |= LOOKUP_REVAL; | ||
1864 | error = __do_follow_link(&path, &nd); | ||
1865 | } | ||
1866 | path_put(&save); | ||
1867 | path_put(&path); | 1870 | path_put(&path); |
1868 | if (error) { | 1871 | if (error) { |
1869 | /* Does someone understand code flow here? Or it is only | 1872 | /* Does someone understand code flow here? Or it is only |
@@ -1873,6 +1876,10 @@ do_link: | |||
1873 | release_open_intent(&nd); | 1876 | release_open_intent(&nd); |
1874 | if (nd.root.mnt) | 1877 | if (nd.root.mnt) |
1875 | path_put(&nd.root); | 1878 | path_put(&nd.root); |
1879 | if (error == -ESTALE && !force_reval) { | ||
1880 | force_reval = 1; | ||
1881 | goto reval; | ||
1882 | } | ||
1876 | return ERR_PTR(error); | 1883 | return ERR_PTR(error); |
1877 | } | 1884 | } |
1878 | nd.flags &= ~LOOKUP_PARENT; | 1885 | nd.flags &= ~LOOKUP_PARENT; |
diff --git a/fs/namespace.c b/fs/namespace.c index 7d70d63ceb29..c768f733c8d6 100644 --- a/fs/namespace.c +++ b/fs/namespace.c | |||
@@ -965,10 +965,12 @@ EXPORT_SYMBOL(may_umount_tree); | |||
965 | int may_umount(struct vfsmount *mnt) | 965 | int may_umount(struct vfsmount *mnt) |
966 | { | 966 | { |
967 | int ret = 1; | 967 | int ret = 1; |
968 | down_read(&namespace_sem); | ||
968 | spin_lock(&vfsmount_lock); | 969 | spin_lock(&vfsmount_lock); |
969 | if (propagate_mount_busy(mnt, 2)) | 970 | if (propagate_mount_busy(mnt, 2)) |
970 | ret = 0; | 971 | ret = 0; |
971 | spin_unlock(&vfsmount_lock); | 972 | spin_unlock(&vfsmount_lock); |
973 | up_read(&namespace_sem); | ||
972 | return ret; | 974 | return ret; |
973 | } | 975 | } |
974 | 976 | ||
@@ -1352,12 +1354,12 @@ static int attach_recursive_mnt(struct vfsmount *source_mnt, | |||
1352 | if (err) | 1354 | if (err) |
1353 | goto out_cleanup_ids; | 1355 | goto out_cleanup_ids; |
1354 | 1356 | ||
1357 | spin_lock(&vfsmount_lock); | ||
1358 | |||
1355 | if (IS_MNT_SHARED(dest_mnt)) { | 1359 | if (IS_MNT_SHARED(dest_mnt)) { |
1356 | for (p = source_mnt; p; p = next_mnt(p, source_mnt)) | 1360 | for (p = source_mnt; p; p = next_mnt(p, source_mnt)) |
1357 | set_mnt_shared(p); | 1361 | set_mnt_shared(p); |
1358 | } | 1362 | } |
1359 | |||
1360 | spin_lock(&vfsmount_lock); | ||
1361 | if (parent_path) { | 1363 | if (parent_path) { |
1362 | detach_mnt(source_mnt, parent_path); | 1364 | detach_mnt(source_mnt, parent_path); |
1363 | attach_mnt(source_mnt, path); | 1365 | attach_mnt(source_mnt, path); |
@@ -1534,8 +1536,12 @@ static int do_remount(struct path *path, int flags, int mnt_flags, | |||
1534 | err = change_mount_flags(path->mnt, flags); | 1536 | err = change_mount_flags(path->mnt, flags); |
1535 | else | 1537 | else |
1536 | err = do_remount_sb(sb, flags, data, 0); | 1538 | err = do_remount_sb(sb, flags, data, 0); |
1537 | if (!err) | 1539 | if (!err) { |
1540 | spin_lock(&vfsmount_lock); | ||
1541 | mnt_flags |= path->mnt->mnt_flags & MNT_PNODE_MASK; | ||
1538 | path->mnt->mnt_flags = mnt_flags; | 1542 | path->mnt->mnt_flags = mnt_flags; |
1543 | spin_unlock(&vfsmount_lock); | ||
1544 | } | ||
1539 | up_write(&sb->s_umount); | 1545 | up_write(&sb->s_umount); |
1540 | if (!err) { | 1546 | if (!err) { |
1541 | security_sb_post_remount(path->mnt, flags, data); | 1547 | security_sb_post_remount(path->mnt, flags, data); |
@@ -1665,6 +1671,8 @@ int do_add_mount(struct vfsmount *newmnt, struct path *path, | |||
1665 | { | 1671 | { |
1666 | int err; | 1672 | int err; |
1667 | 1673 | ||
1674 | mnt_flags &= ~(MNT_SHARED | MNT_WRITE_HOLD); | ||
1675 | |||
1668 | down_write(&namespace_sem); | 1676 | down_write(&namespace_sem); |
1669 | /* Something was mounted here while we slept */ | 1677 | /* Something was mounted here while we slept */ |
1670 | while (d_mountpoint(path->dentry) && | 1678 | while (d_mountpoint(path->dentry) && |
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c index e1d415e97849..0d289823e856 100644 --- a/fs/nfs/direct.c +++ b/fs/nfs/direct.c | |||
@@ -342,6 +342,7 @@ static ssize_t nfs_direct_read_schedule_segment(struct nfs_direct_req *dreq, | |||
342 | data->res.fattr = &data->fattr; | 342 | data->res.fattr = &data->fattr; |
343 | data->res.eof = 0; | 343 | data->res.eof = 0; |
344 | data->res.count = bytes; | 344 | data->res.count = bytes; |
345 | nfs_fattr_init(&data->fattr); | ||
345 | msg.rpc_argp = &data->args; | 346 | msg.rpc_argp = &data->args; |
346 | msg.rpc_resp = &data->res; | 347 | msg.rpc_resp = &data->res; |
347 | 348 | ||
@@ -575,6 +576,7 @@ static void nfs_direct_commit_schedule(struct nfs_direct_req *dreq) | |||
575 | data->res.count = 0; | 576 | data->res.count = 0; |
576 | data->res.fattr = &data->fattr; | 577 | data->res.fattr = &data->fattr; |
577 | data->res.verf = &data->verf; | 578 | data->res.verf = &data->verf; |
579 | nfs_fattr_init(&data->fattr); | ||
578 | 580 | ||
579 | NFS_PROTO(data->inode)->commit_setup(data, &msg); | 581 | NFS_PROTO(data->inode)->commit_setup(data, &msg); |
580 | 582 | ||
@@ -766,6 +768,7 @@ static ssize_t nfs_direct_write_schedule_segment(struct nfs_direct_req *dreq, | |||
766 | data->res.fattr = &data->fattr; | 768 | data->res.fattr = &data->fattr; |
767 | data->res.count = bytes; | 769 | data->res.count = bytes; |
768 | data->res.verf = &data->verf; | 770 | data->res.verf = &data->verf; |
771 | nfs_fattr_init(&data->fattr); | ||
769 | 772 | ||
770 | task_setup_data.task = &data->task; | 773 | task_setup_data.task = &data->task; |
771 | task_setup_data.callback_data = data; | 774 | task_setup_data.callback_data = data; |
diff --git a/fs/nfs/file.c b/fs/nfs/file.c index 6b891328f332..63f2071d6445 100644 --- a/fs/nfs/file.c +++ b/fs/nfs/file.c | |||
@@ -486,6 +486,8 @@ static int nfs_release_page(struct page *page, gfp_t gfp) | |||
486 | { | 486 | { |
487 | dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page); | 487 | dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page); |
488 | 488 | ||
489 | if (gfp & __GFP_WAIT) | ||
490 | nfs_wb_page(page->mapping->host, page); | ||
489 | /* If PagePrivate() is set, then the page is not freeable */ | 491 | /* If PagePrivate() is set, then the page is not freeable */ |
490 | if (PagePrivate(page)) | 492 | if (PagePrivate(page)) |
491 | return 0; | 493 | return 0; |
diff --git a/fs/nfs/fscache.c b/fs/nfs/fscache.c index fa588006588d..237874f1af23 100644 --- a/fs/nfs/fscache.c +++ b/fs/nfs/fscache.c | |||
@@ -354,12 +354,11 @@ void nfs_fscache_reset_inode_cookie(struct inode *inode) | |||
354 | */ | 354 | */ |
355 | int nfs_fscache_release_page(struct page *page, gfp_t gfp) | 355 | int nfs_fscache_release_page(struct page *page, gfp_t gfp) |
356 | { | 356 | { |
357 | struct nfs_inode *nfsi = NFS_I(page->mapping->host); | ||
358 | struct fscache_cookie *cookie = nfsi->fscache; | ||
359 | |||
360 | BUG_ON(!cookie); | ||
361 | |||
362 | if (PageFsCache(page)) { | 357 | if (PageFsCache(page)) { |
358 | struct nfs_inode *nfsi = NFS_I(page->mapping->host); | ||
359 | struct fscache_cookie *cookie = nfsi->fscache; | ||
360 | |||
361 | BUG_ON(!cookie); | ||
363 | dfprintk(FSCACHE, "NFS: fscache releasepage (0x%p/0x%p/0x%p)\n", | 362 | dfprintk(FSCACHE, "NFS: fscache releasepage (0x%p/0x%p/0x%p)\n", |
364 | cookie, page, nfsi); | 363 | cookie, page, nfsi); |
365 | 364 | ||
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c index faa091865ad0..f141bde7756a 100644 --- a/fs/nfs/inode.c +++ b/fs/nfs/inode.c | |||
@@ -1261,8 +1261,10 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1261 | 1261 | ||
1262 | if (fattr->valid & NFS_ATTR_FATTR_MODE) { | 1262 | if (fattr->valid & NFS_ATTR_FATTR_MODE) { |
1263 | if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) { | 1263 | if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) { |
1264 | umode_t newmode = inode->i_mode & S_IFMT; | ||
1265 | newmode |= fattr->mode & S_IALLUGO; | ||
1266 | inode->i_mode = newmode; | ||
1264 | invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; | 1267 | invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; |
1265 | inode->i_mode = fattr->mode; | ||
1266 | } | 1268 | } |
1267 | } else if (server->caps & NFS_CAP_MODE) | 1269 | } else if (server->caps & NFS_CAP_MODE) |
1268 | invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR | 1270 | invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR |
diff --git a/fs/nfs/mount_clnt.c b/fs/nfs/mount_clnt.c index 0adefc40cc89..59047f8d7d72 100644 --- a/fs/nfs/mount_clnt.c +++ b/fs/nfs/mount_clnt.c | |||
@@ -120,7 +120,7 @@ static struct { | |||
120 | { .status = MNT3ERR_INVAL, .errno = -EINVAL, }, | 120 | { .status = MNT3ERR_INVAL, .errno = -EINVAL, }, |
121 | { .status = MNT3ERR_NAMETOOLONG, .errno = -ENAMETOOLONG, }, | 121 | { .status = MNT3ERR_NAMETOOLONG, .errno = -ENAMETOOLONG, }, |
122 | { .status = MNT3ERR_NOTSUPP, .errno = -ENOTSUPP, }, | 122 | { .status = MNT3ERR_NOTSUPP, .errno = -ENOTSUPP, }, |
123 | { .status = MNT3ERR_SERVERFAULT, .errno = -ESERVERFAULT, }, | 123 | { .status = MNT3ERR_SERVERFAULT, .errno = -EREMOTEIO, }, |
124 | }; | 124 | }; |
125 | 125 | ||
126 | struct mountres { | 126 | struct mountres { |
diff --git a/fs/nfs/nfs2xdr.c b/fs/nfs/nfs2xdr.c index 5e078b222b4e..7bc2da8efd4a 100644 --- a/fs/nfs/nfs2xdr.c +++ b/fs/nfs/nfs2xdr.c | |||
@@ -699,7 +699,7 @@ static struct { | |||
699 | { NFSERR_BAD_COOKIE, -EBADCOOKIE }, | 699 | { NFSERR_BAD_COOKIE, -EBADCOOKIE }, |
700 | { NFSERR_NOTSUPP, -ENOTSUPP }, | 700 | { NFSERR_NOTSUPP, -ENOTSUPP }, |
701 | { NFSERR_TOOSMALL, -ETOOSMALL }, | 701 | { NFSERR_TOOSMALL, -ETOOSMALL }, |
702 | { NFSERR_SERVERFAULT, -ESERVERFAULT }, | 702 | { NFSERR_SERVERFAULT, -EREMOTEIO }, |
703 | { NFSERR_BADTYPE, -EBADTYPE }, | 703 | { NFSERR_BADTYPE, -EBADTYPE }, |
704 | { NFSERR_JUKEBOX, -EJUKEBOX }, | 704 | { NFSERR_JUKEBOX, -EJUKEBOX }, |
705 | { -1, -EIO } | 705 | { -1, -EIO } |
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h index 865265bdca03..0c6fda33d66e 100644 --- a/fs/nfs/nfs4_fs.h +++ b/fs/nfs/nfs4_fs.h | |||
@@ -146,6 +146,7 @@ enum { | |||
146 | NFS_O_RDWR_STATE, /* OPEN stateid has read/write state */ | 146 | NFS_O_RDWR_STATE, /* OPEN stateid has read/write state */ |
147 | NFS_STATE_RECLAIM_REBOOT, /* OPEN stateid server rebooted */ | 147 | NFS_STATE_RECLAIM_REBOOT, /* OPEN stateid server rebooted */ |
148 | NFS_STATE_RECLAIM_NOGRACE, /* OPEN stateid needs to recover state */ | 148 | NFS_STATE_RECLAIM_NOGRACE, /* OPEN stateid needs to recover state */ |
149 | NFS_STATE_POSIX_LOCKS, /* Posix locks are supported */ | ||
149 | }; | 150 | }; |
150 | 151 | ||
151 | struct nfs4_state { | 152 | struct nfs4_state { |
@@ -277,6 +278,7 @@ extern void nfs4_state_set_mode_locked(struct nfs4_state *, fmode_t); | |||
277 | extern void nfs4_schedule_state_recovery(struct nfs_client *); | 278 | extern void nfs4_schedule_state_recovery(struct nfs_client *); |
278 | extern void nfs4_schedule_state_manager(struct nfs_client *); | 279 | extern void nfs4_schedule_state_manager(struct nfs_client *); |
279 | extern int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state); | 280 | extern int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state); |
281 | extern int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state); | ||
280 | extern void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags); | 282 | extern void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags); |
281 | extern void nfs4_put_lock_state(struct nfs4_lock_state *lsp); | 283 | extern void nfs4_put_lock_state(struct nfs4_lock_state *lsp); |
282 | extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl); | 284 | extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl); |
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c index 198d51d17c13..375f0fae2c6a 100644 --- a/fs/nfs/nfs4proc.c +++ b/fs/nfs/nfs4proc.c | |||
@@ -249,19 +249,15 @@ static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, | |||
249 | if (state == NULL) | 249 | if (state == NULL) |
250 | break; | 250 | break; |
251 | nfs4_state_mark_reclaim_nograce(clp, state); | 251 | nfs4_state_mark_reclaim_nograce(clp, state); |
252 | case -NFS4ERR_STALE_CLIENTID: | 252 | goto do_state_recovery; |
253 | case -NFS4ERR_STALE_STATEID: | 253 | case -NFS4ERR_STALE_STATEID: |
254 | case -NFS4ERR_EXPIRED: | 254 | if (state == NULL) |
255 | nfs4_schedule_state_recovery(clp); | ||
256 | ret = nfs4_wait_clnt_recover(clp); | ||
257 | if (ret == 0) | ||
258 | exception->retry = 1; | ||
259 | #if !defined(CONFIG_NFS_V4_1) | ||
260 | break; | ||
261 | #else /* !defined(CONFIG_NFS_V4_1) */ | ||
262 | if (!nfs4_has_session(server->nfs_client)) | ||
263 | break; | 255 | break; |
264 | /* FALLTHROUGH */ | 256 | nfs4_state_mark_reclaim_reboot(clp, state); |
257 | case -NFS4ERR_STALE_CLIENTID: | ||
258 | case -NFS4ERR_EXPIRED: | ||
259 | goto do_state_recovery; | ||
260 | #if defined(CONFIG_NFS_V4_1) | ||
265 | case -NFS4ERR_BADSESSION: | 261 | case -NFS4ERR_BADSESSION: |
266 | case -NFS4ERR_BADSLOT: | 262 | case -NFS4ERR_BADSLOT: |
267 | case -NFS4ERR_BAD_HIGH_SLOT: | 263 | case -NFS4ERR_BAD_HIGH_SLOT: |
@@ -274,7 +270,7 @@ static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, | |||
274 | nfs4_schedule_state_recovery(clp); | 270 | nfs4_schedule_state_recovery(clp); |
275 | exception->retry = 1; | 271 | exception->retry = 1; |
276 | break; | 272 | break; |
277 | #endif /* !defined(CONFIG_NFS_V4_1) */ | 273 | #endif /* defined(CONFIG_NFS_V4_1) */ |
278 | case -NFS4ERR_FILE_OPEN: | 274 | case -NFS4ERR_FILE_OPEN: |
279 | if (exception->timeout > HZ) { | 275 | if (exception->timeout > HZ) { |
280 | /* We have retried a decent amount, time to | 276 | /* We have retried a decent amount, time to |
@@ -293,6 +289,12 @@ static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, | |||
293 | } | 289 | } |
294 | /* We failed to handle the error */ | 290 | /* We failed to handle the error */ |
295 | return nfs4_map_errors(ret); | 291 | return nfs4_map_errors(ret); |
292 | do_state_recovery: | ||
293 | nfs4_schedule_state_recovery(clp); | ||
294 | ret = nfs4_wait_clnt_recover(clp); | ||
295 | if (ret == 0) | ||
296 | exception->retry = 1; | ||
297 | return ret; | ||
296 | } | 298 | } |
297 | 299 | ||
298 | 300 | ||
@@ -1658,6 +1660,8 @@ static int _nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, in | |||
1658 | status = PTR_ERR(state); | 1660 | status = PTR_ERR(state); |
1659 | if (IS_ERR(state)) | 1661 | if (IS_ERR(state)) |
1660 | goto err_opendata_put; | 1662 | goto err_opendata_put; |
1663 | if ((opendata->o_res.rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) != 0) | ||
1664 | set_bit(NFS_STATE_POSIX_LOCKS, &state->flags); | ||
1661 | nfs4_opendata_put(opendata); | 1665 | nfs4_opendata_put(opendata); |
1662 | nfs4_put_state_owner(sp); | 1666 | nfs4_put_state_owner(sp); |
1663 | *res = state; | 1667 | *res = state; |
@@ -3422,15 +3426,14 @@ _nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, | |||
3422 | if (state == NULL) | 3426 | if (state == NULL) |
3423 | break; | 3427 | break; |
3424 | nfs4_state_mark_reclaim_nograce(clp, state); | 3428 | nfs4_state_mark_reclaim_nograce(clp, state); |
3425 | case -NFS4ERR_STALE_CLIENTID: | 3429 | goto do_state_recovery; |
3426 | case -NFS4ERR_STALE_STATEID: | 3430 | case -NFS4ERR_STALE_STATEID: |
3431 | if (state == NULL) | ||
3432 | break; | ||
3433 | nfs4_state_mark_reclaim_reboot(clp, state); | ||
3434 | case -NFS4ERR_STALE_CLIENTID: | ||
3427 | case -NFS4ERR_EXPIRED: | 3435 | case -NFS4ERR_EXPIRED: |
3428 | rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL); | 3436 | goto do_state_recovery; |
3429 | nfs4_schedule_state_recovery(clp); | ||
3430 | if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0) | ||
3431 | rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task); | ||
3432 | task->tk_status = 0; | ||
3433 | return -EAGAIN; | ||
3434 | #if defined(CONFIG_NFS_V4_1) | 3437 | #if defined(CONFIG_NFS_V4_1) |
3435 | case -NFS4ERR_BADSESSION: | 3438 | case -NFS4ERR_BADSESSION: |
3436 | case -NFS4ERR_BADSLOT: | 3439 | case -NFS4ERR_BADSLOT: |
@@ -3458,6 +3461,13 @@ _nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, | |||
3458 | } | 3461 | } |
3459 | task->tk_status = nfs4_map_errors(task->tk_status); | 3462 | task->tk_status = nfs4_map_errors(task->tk_status); |
3460 | return 0; | 3463 | return 0; |
3464 | do_state_recovery: | ||
3465 | rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL); | ||
3466 | nfs4_schedule_state_recovery(clp); | ||
3467 | if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0) | ||
3468 | rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task); | ||
3469 | task->tk_status = 0; | ||
3470 | return -EAGAIN; | ||
3461 | } | 3471 | } |
3462 | 3472 | ||
3463 | static int | 3473 | static int |
@@ -4088,6 +4098,28 @@ static const struct rpc_call_ops nfs4_recover_lock_ops = { | |||
4088 | .rpc_release = nfs4_lock_release, | 4098 | .rpc_release = nfs4_lock_release, |
4089 | }; | 4099 | }; |
4090 | 4100 | ||
4101 | static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error) | ||
4102 | { | ||
4103 | struct nfs_client *clp = server->nfs_client; | ||
4104 | struct nfs4_state *state = lsp->ls_state; | ||
4105 | |||
4106 | switch (error) { | ||
4107 | case -NFS4ERR_ADMIN_REVOKED: | ||
4108 | case -NFS4ERR_BAD_STATEID: | ||
4109 | case -NFS4ERR_EXPIRED: | ||
4110 | if (new_lock_owner != 0 || | ||
4111 | (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0) | ||
4112 | nfs4_state_mark_reclaim_nograce(clp, state); | ||
4113 | lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; | ||
4114 | break; | ||
4115 | case -NFS4ERR_STALE_STATEID: | ||
4116 | if (new_lock_owner != 0 || | ||
4117 | (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0) | ||
4118 | nfs4_state_mark_reclaim_reboot(clp, state); | ||
4119 | lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; | ||
4120 | }; | ||
4121 | } | ||
4122 | |||
4091 | static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type) | 4123 | static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type) |
4092 | { | 4124 | { |
4093 | struct nfs4_lockdata *data; | 4125 | struct nfs4_lockdata *data; |
@@ -4126,6 +4158,9 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f | |||
4126 | ret = nfs4_wait_for_completion_rpc_task(task); | 4158 | ret = nfs4_wait_for_completion_rpc_task(task); |
4127 | if (ret == 0) { | 4159 | if (ret == 0) { |
4128 | ret = data->rpc_status; | 4160 | ret = data->rpc_status; |
4161 | if (ret) | ||
4162 | nfs4_handle_setlk_error(data->server, data->lsp, | ||
4163 | data->arg.new_lock_owner, ret); | ||
4129 | } else | 4164 | } else |
4130 | data->cancelled = 1; | 4165 | data->cancelled = 1; |
4131 | rpc_put_task(task); | 4166 | rpc_put_task(task); |
@@ -4181,8 +4216,11 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock | |||
4181 | { | 4216 | { |
4182 | struct nfs_inode *nfsi = NFS_I(state->inode); | 4217 | struct nfs_inode *nfsi = NFS_I(state->inode); |
4183 | unsigned char fl_flags = request->fl_flags; | 4218 | unsigned char fl_flags = request->fl_flags; |
4184 | int status; | 4219 | int status = -ENOLCK; |
4185 | 4220 | ||
4221 | if ((fl_flags & FL_POSIX) && | ||
4222 | !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags)) | ||
4223 | goto out; | ||
4186 | /* Is this a delegated open? */ | 4224 | /* Is this a delegated open? */ |
4187 | status = nfs4_set_lock_state(state, request); | 4225 | status = nfs4_set_lock_state(state, request); |
4188 | if (status != 0) | 4226 | if (status != 0) |
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c index 6d263ed79e92..c1e2733f4fa4 100644 --- a/fs/nfs/nfs4state.c +++ b/fs/nfs/nfs4state.c | |||
@@ -901,7 +901,7 @@ void nfs4_schedule_state_recovery(struct nfs_client *clp) | |||
901 | nfs4_schedule_state_manager(clp); | 901 | nfs4_schedule_state_manager(clp); |
902 | } | 902 | } |
903 | 903 | ||
904 | static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state) | 904 | int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state) |
905 | { | 905 | { |
906 | 906 | ||
907 | set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); | 907 | set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); |
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c index e437fd6a819f..5cd5184b56db 100644 --- a/fs/nfs/nfs4xdr.c +++ b/fs/nfs/nfs4xdr.c | |||
@@ -4631,7 +4631,7 @@ static int decode_sequence(struct xdr_stream *xdr, | |||
4631 | * If the server returns different values for sessionID, slotID or | 4631 | * If the server returns different values for sessionID, slotID or |
4632 | * sequence number, the server is looney tunes. | 4632 | * sequence number, the server is looney tunes. |
4633 | */ | 4633 | */ |
4634 | status = -ESERVERFAULT; | 4634 | status = -EREMOTEIO; |
4635 | 4635 | ||
4636 | if (memcmp(id.data, res->sr_session->sess_id.data, | 4636 | if (memcmp(id.data, res->sr_session->sess_id.data, |
4637 | NFS4_MAX_SESSIONID_LEN)) { | 4637 | NFS4_MAX_SESSIONID_LEN)) { |
@@ -5774,7 +5774,7 @@ static struct { | |||
5774 | { NFS4ERR_BAD_COOKIE, -EBADCOOKIE }, | 5774 | { NFS4ERR_BAD_COOKIE, -EBADCOOKIE }, |
5775 | { NFS4ERR_NOTSUPP, -ENOTSUPP }, | 5775 | { NFS4ERR_NOTSUPP, -ENOTSUPP }, |
5776 | { NFS4ERR_TOOSMALL, -ETOOSMALL }, | 5776 | { NFS4ERR_TOOSMALL, -ETOOSMALL }, |
5777 | { NFS4ERR_SERVERFAULT, -ESERVERFAULT }, | 5777 | { NFS4ERR_SERVERFAULT, -EREMOTEIO }, |
5778 | { NFS4ERR_BADTYPE, -EBADTYPE }, | 5778 | { NFS4ERR_BADTYPE, -EBADTYPE }, |
5779 | { NFS4ERR_LOCKED, -EAGAIN }, | 5779 | { NFS4ERR_LOCKED, -EAGAIN }, |
5780 | { NFS4ERR_SYMLINK, -ELOOP }, | 5780 | { NFS4ERR_SYMLINK, -ELOOP }, |
@@ -5801,7 +5801,7 @@ nfs4_stat_to_errno(int stat) | |||
5801 | } | 5801 | } |
5802 | if (stat <= 10000 || stat > 10100) { | 5802 | if (stat <= 10000 || stat > 10100) { |
5803 | /* The server is looney tunes. */ | 5803 | /* The server is looney tunes. */ |
5804 | return -ESERVERFAULT; | 5804 | return -EREMOTEIO; |
5805 | } | 5805 | } |
5806 | /* If we cannot translate the error, the recovery routines should | 5806 | /* If we cannot translate the error, the recovery routines should |
5807 | * handle it. | 5807 | * handle it. |
diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c index e2975939126a..a12c45b65dd4 100644 --- a/fs/nfs/pagelist.c +++ b/fs/nfs/pagelist.c | |||
@@ -176,6 +176,12 @@ void nfs_release_request(struct nfs_page *req) | |||
176 | kref_put(&req->wb_kref, nfs_free_request); | 176 | kref_put(&req->wb_kref, nfs_free_request); |
177 | } | 177 | } |
178 | 178 | ||
179 | static int nfs_wait_bit_uninterruptible(void *word) | ||
180 | { | ||
181 | io_schedule(); | ||
182 | return 0; | ||
183 | } | ||
184 | |||
179 | /** | 185 | /** |
180 | * nfs_wait_on_request - Wait for a request to complete. | 186 | * nfs_wait_on_request - Wait for a request to complete. |
181 | * @req: request to wait upon. | 187 | * @req: request to wait upon. |
@@ -186,14 +192,9 @@ void nfs_release_request(struct nfs_page *req) | |||
186 | int | 192 | int |
187 | nfs_wait_on_request(struct nfs_page *req) | 193 | nfs_wait_on_request(struct nfs_page *req) |
188 | { | 194 | { |
189 | int ret = 0; | 195 | return wait_on_bit(&req->wb_flags, PG_BUSY, |
190 | 196 | nfs_wait_bit_uninterruptible, | |
191 | if (!test_bit(PG_BUSY, &req->wb_flags)) | 197 | TASK_UNINTERRUPTIBLE); |
192 | goto out; | ||
193 | ret = out_of_line_wait_on_bit(&req->wb_flags, PG_BUSY, | ||
194 | nfs_wait_bit_killable, TASK_KILLABLE); | ||
195 | out: | ||
196 | return ret; | ||
197 | } | 198 | } |
198 | 199 | ||
199 | /** | 200 | /** |
diff --git a/fs/nfs/super.c b/fs/nfs/super.c index ce907efc5508..f1afee4eea77 100644 --- a/fs/nfs/super.c +++ b/fs/nfs/super.c | |||
@@ -243,6 +243,7 @@ static int nfs_show_stats(struct seq_file *, struct vfsmount *); | |||
243 | static int nfs_get_sb(struct file_system_type *, int, const char *, void *, struct vfsmount *); | 243 | static int nfs_get_sb(struct file_system_type *, int, const char *, void *, struct vfsmount *); |
244 | static int nfs_xdev_get_sb(struct file_system_type *fs_type, | 244 | static int nfs_xdev_get_sb(struct file_system_type *fs_type, |
245 | int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt); | 245 | int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt); |
246 | static void nfs_put_super(struct super_block *); | ||
246 | static void nfs_kill_super(struct super_block *); | 247 | static void nfs_kill_super(struct super_block *); |
247 | static int nfs_remount(struct super_block *sb, int *flags, char *raw_data); | 248 | static int nfs_remount(struct super_block *sb, int *flags, char *raw_data); |
248 | 249 | ||
@@ -266,6 +267,7 @@ static const struct super_operations nfs_sops = { | |||
266 | .alloc_inode = nfs_alloc_inode, | 267 | .alloc_inode = nfs_alloc_inode, |
267 | .destroy_inode = nfs_destroy_inode, | 268 | .destroy_inode = nfs_destroy_inode, |
268 | .write_inode = nfs_write_inode, | 269 | .write_inode = nfs_write_inode, |
270 | .put_super = nfs_put_super, | ||
269 | .statfs = nfs_statfs, | 271 | .statfs = nfs_statfs, |
270 | .clear_inode = nfs_clear_inode, | 272 | .clear_inode = nfs_clear_inode, |
271 | .umount_begin = nfs_umount_begin, | 273 | .umount_begin = nfs_umount_begin, |
@@ -335,6 +337,7 @@ static const struct super_operations nfs4_sops = { | |||
335 | .alloc_inode = nfs_alloc_inode, | 337 | .alloc_inode = nfs_alloc_inode, |
336 | .destroy_inode = nfs_destroy_inode, | 338 | .destroy_inode = nfs_destroy_inode, |
337 | .write_inode = nfs_write_inode, | 339 | .write_inode = nfs_write_inode, |
340 | .put_super = nfs_put_super, | ||
338 | .statfs = nfs_statfs, | 341 | .statfs = nfs_statfs, |
339 | .clear_inode = nfs4_clear_inode, | 342 | .clear_inode = nfs4_clear_inode, |
340 | .umount_begin = nfs_umount_begin, | 343 | .umount_begin = nfs_umount_begin, |
@@ -2258,6 +2261,17 @@ error_splat_super: | |||
2258 | } | 2261 | } |
2259 | 2262 | ||
2260 | /* | 2263 | /* |
2264 | * Ensure that we unregister the bdi before kill_anon_super | ||
2265 | * releases the device name | ||
2266 | */ | ||
2267 | static void nfs_put_super(struct super_block *s) | ||
2268 | { | ||
2269 | struct nfs_server *server = NFS_SB(s); | ||
2270 | |||
2271 | bdi_unregister(&server->backing_dev_info); | ||
2272 | } | ||
2273 | |||
2274 | /* | ||
2261 | * Destroy an NFS2/3 superblock | 2275 | * Destroy an NFS2/3 superblock |
2262 | */ | 2276 | */ |
2263 | static void nfs_kill_super(struct super_block *s) | 2277 | static void nfs_kill_super(struct super_block *s) |
@@ -2265,7 +2279,6 @@ static void nfs_kill_super(struct super_block *s) | |||
2265 | struct nfs_server *server = NFS_SB(s); | 2279 | struct nfs_server *server = NFS_SB(s); |
2266 | 2280 | ||
2267 | kill_anon_super(s); | 2281 | kill_anon_super(s); |
2268 | bdi_unregister(&server->backing_dev_info); | ||
2269 | nfs_fscache_release_super_cookie(s); | 2282 | nfs_fscache_release_super_cookie(s); |
2270 | nfs_free_server(server); | 2283 | nfs_free_server(server); |
2271 | } | 2284 | } |
diff --git a/fs/nfs/sysctl.c b/fs/nfs/sysctl.c index 70e1fbbaaeab..ad4d2e787b20 100644 --- a/fs/nfs/sysctl.c +++ b/fs/nfs/sysctl.c | |||
@@ -15,8 +15,10 @@ | |||
15 | 15 | ||
16 | #include "callback.h" | 16 | #include "callback.h" |
17 | 17 | ||
18 | #ifdef CONFIG_NFS_V4 | ||
18 | static const int nfs_set_port_min = 0; | 19 | static const int nfs_set_port_min = 0; |
19 | static const int nfs_set_port_max = 65535; | 20 | static const int nfs_set_port_max = 65535; |
21 | #endif | ||
20 | static struct ctl_table_header *nfs_callback_sysctl_table; | 22 | static struct ctl_table_header *nfs_callback_sysctl_table; |
21 | 23 | ||
22 | static ctl_table nfs_cb_sysctls[] = { | 24 | static ctl_table nfs_cb_sysctls[] = { |
diff --git a/fs/nfs/write.c b/fs/nfs/write.c index d171696017f4..d63d964a0392 100644 --- a/fs/nfs/write.c +++ b/fs/nfs/write.c | |||
@@ -1233,7 +1233,7 @@ int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data) | |||
1233 | 1233 | ||
1234 | 1234 | ||
1235 | #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4) | 1235 | #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4) |
1236 | void nfs_commitdata_release(void *data) | 1236 | static void nfs_commitdata_release(void *data) |
1237 | { | 1237 | { |
1238 | struct nfs_write_data *wdata = data; | 1238 | struct nfs_write_data *wdata = data; |
1239 | 1239 | ||
@@ -1541,6 +1541,7 @@ int nfs_wb_page_cancel(struct inode *inode, struct page *page) | |||
1541 | break; | 1541 | break; |
1542 | } | 1542 | } |
1543 | ret = nfs_wait_on_request(req); | 1543 | ret = nfs_wait_on_request(req); |
1544 | nfs_release_request(req); | ||
1544 | if (ret < 0) | 1545 | if (ret < 0) |
1545 | goto out; | 1546 | goto out; |
1546 | } | 1547 | } |
@@ -1597,8 +1598,7 @@ int nfs_migrate_page(struct address_space *mapping, struct page *newpage, | |||
1597 | struct nfs_page *req; | 1598 | struct nfs_page *req; |
1598 | int ret; | 1599 | int ret; |
1599 | 1600 | ||
1600 | if (PageFsCache(page)) | 1601 | nfs_fscache_release_page(page, GFP_KERNEL); |
1601 | nfs_fscache_release_page(page, GFP_KERNEL); | ||
1602 | 1602 | ||
1603 | req = nfs_find_and_lock_request(page); | 1603 | req = nfs_find_and_lock_request(page); |
1604 | ret = PTR_ERR(req); | 1604 | ret = PTR_ERR(req); |
diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c index c487810a2366..a0c4016413f1 100644 --- a/fs/nfsd/export.c +++ b/fs/nfsd/export.c | |||
@@ -1316,19 +1316,11 @@ rqst_exp_parent(struct svc_rqst *rqstp, struct path *path) | |||
1316 | 1316 | ||
1317 | static struct svc_export *find_fsidzero_export(struct svc_rqst *rqstp) | 1317 | static struct svc_export *find_fsidzero_export(struct svc_rqst *rqstp) |
1318 | { | 1318 | { |
1319 | struct svc_export *exp; | ||
1320 | u32 fsidv[2]; | 1319 | u32 fsidv[2]; |
1321 | 1320 | ||
1322 | mk_fsid(FSID_NUM, fsidv, 0, 0, 0, NULL); | 1321 | mk_fsid(FSID_NUM, fsidv, 0, 0, 0, NULL); |
1323 | 1322 | ||
1324 | exp = rqst_exp_find(rqstp, FSID_NUM, fsidv); | 1323 | return rqst_exp_find(rqstp, FSID_NUM, fsidv); |
1325 | /* | ||
1326 | * We shouldn't have accepting an nfsv4 request at all if we | ||
1327 | * don't have a pseudoexport!: | ||
1328 | */ | ||
1329 | if (IS_ERR(exp) && PTR_ERR(exp) == -ENOENT) | ||
1330 | exp = ERR_PTR(-ESERVERFAULT); | ||
1331 | return exp; | ||
1332 | } | 1324 | } |
1333 | 1325 | ||
1334 | /* | 1326 | /* |
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c index c194793b642b..8715d194561a 100644 --- a/fs/nfsd/vfs.c +++ b/fs/nfsd/vfs.c | |||
@@ -752,6 +752,8 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, | |||
752 | flags, current_cred()); | 752 | flags, current_cred()); |
753 | if (IS_ERR(*filp)) | 753 | if (IS_ERR(*filp)) |
754 | host_err = PTR_ERR(*filp); | 754 | host_err = PTR_ERR(*filp); |
755 | else | ||
756 | host_err = ima_file_check(*filp, access); | ||
755 | out_nfserr: | 757 | out_nfserr: |
756 | err = nfserrno(host_err); | 758 | err = nfserrno(host_err); |
757 | out: | 759 | out: |
@@ -2127,7 +2129,6 @@ nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp, | |||
2127 | */ | 2129 | */ |
2128 | path.mnt = exp->ex_path.mnt; | 2130 | path.mnt = exp->ex_path.mnt; |
2129 | path.dentry = dentry; | 2131 | path.dentry = dentry; |
2130 | err = ima_path_check(&path, acc & (MAY_READ | MAY_WRITE | MAY_EXEC)); | ||
2131 | nfsd_out: | 2132 | nfsd_out: |
2132 | return err? nfserrno(err) : 0; | 2133 | return err? nfserrno(err) : 0; |
2133 | } | 2134 | } |
diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c index 17584c524486..105b508b47a8 100644 --- a/fs/nilfs2/segment.c +++ b/fs/nilfs2/segment.c | |||
@@ -2829,7 +2829,7 @@ static void nilfs_segctor_destroy(struct nilfs_sc_info *sci) | |||
2829 | || sci->sc_seq_request != sci->sc_seq_done); | 2829 | || sci->sc_seq_request != sci->sc_seq_done); |
2830 | spin_unlock(&sci->sc_state_lock); | 2830 | spin_unlock(&sci->sc_state_lock); |
2831 | 2831 | ||
2832 | if (flag || nilfs_segctor_confirm(sci)) | 2832 | if (flag || !nilfs_segctor_confirm(sci)) |
2833 | nilfs_segctor_write_out(sci); | 2833 | nilfs_segctor_write_out(sci); |
2834 | 2834 | ||
2835 | WARN_ON(!list_empty(&sci->sc_copied_buffers)); | 2835 | WARN_ON(!list_empty(&sci->sc_copied_buffers)); |
diff --git a/fs/notify/inotify/inotify_fsnotify.c b/fs/notify/inotify/inotify_fsnotify.c index c9ee67b442e1..1afb0a10229f 100644 --- a/fs/notify/inotify/inotify_fsnotify.c +++ b/fs/notify/inotify/inotify_fsnotify.c | |||
@@ -121,7 +121,7 @@ static int idr_callback(int id, void *p, void *data) | |||
121 | if (warned) | 121 | if (warned) |
122 | return 0; | 122 | return 0; |
123 | 123 | ||
124 | warned = false; | 124 | warned = true; |
125 | entry = p; | 125 | entry = p; |
126 | ientry = container_of(entry, struct inotify_inode_mark_entry, fsn_entry); | 126 | ientry = container_of(entry, struct inotify_inode_mark_entry, fsn_entry); |
127 | 127 | ||
diff --git a/fs/notify/inotify/inotify_user.c b/fs/notify/inotify/inotify_user.c index 8271cf05c957..a94e8bd8eb1f 100644 --- a/fs/notify/inotify/inotify_user.c +++ b/fs/notify/inotify/inotify_user.c | |||
@@ -552,7 +552,7 @@ retry: | |||
552 | 552 | ||
553 | spin_lock(&group->inotify_data.idr_lock); | 553 | spin_lock(&group->inotify_data.idr_lock); |
554 | ret = idr_get_new_above(&group->inotify_data.idr, &tmp_ientry->fsn_entry, | 554 | ret = idr_get_new_above(&group->inotify_data.idr, &tmp_ientry->fsn_entry, |
555 | group->inotify_data.last_wd, | 555 | group->inotify_data.last_wd+1, |
556 | &tmp_ientry->wd); | 556 | &tmp_ientry->wd); |
557 | spin_unlock(&group->inotify_data.idr_lock); | 557 | spin_unlock(&group->inotify_data.idr_lock); |
558 | if (ret) { | 558 | if (ret) { |
@@ -632,7 +632,7 @@ static struct fsnotify_group *inotify_new_group(struct user_struct *user, unsign | |||
632 | 632 | ||
633 | spin_lock_init(&group->inotify_data.idr_lock); | 633 | spin_lock_init(&group->inotify_data.idr_lock); |
634 | idr_init(&group->inotify_data.idr); | 634 | idr_init(&group->inotify_data.idr); |
635 | group->inotify_data.last_wd = 1; | 635 | group->inotify_data.last_wd = 0; |
636 | group->inotify_data.user = user; | 636 | group->inotify_data.user = user; |
637 | group->inotify_data.fa = NULL; | 637 | group->inotify_data.fa = NULL; |
638 | 638 | ||
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c index 3dae4a13f6e4..7e9df11260f4 100644 --- a/fs/ocfs2/aops.c +++ b/fs/ocfs2/aops.c | |||
@@ -599,7 +599,7 @@ bail: | |||
599 | return ret; | 599 | return ret; |
600 | } | 600 | } |
601 | 601 | ||
602 | /* | 602 | /* |
603 | * ocfs2_dio_end_io is called by the dio core when a dio is finished. We're | 603 | * ocfs2_dio_end_io is called by the dio core when a dio is finished. We're |
604 | * particularly interested in the aio/dio case. Like the core uses | 604 | * particularly interested in the aio/dio case. Like the core uses |
605 | * i_alloc_sem, we use the rw_lock DLM lock to protect io on one node from | 605 | * i_alloc_sem, we use the rw_lock DLM lock to protect io on one node from |
@@ -670,7 +670,7 @@ static ssize_t ocfs2_direct_IO(int rw, | |||
670 | 670 | ||
671 | ret = blockdev_direct_IO_no_locking(rw, iocb, inode, | 671 | ret = blockdev_direct_IO_no_locking(rw, iocb, inode, |
672 | inode->i_sb->s_bdev, iov, offset, | 672 | inode->i_sb->s_bdev, iov, offset, |
673 | nr_segs, | 673 | nr_segs, |
674 | ocfs2_direct_IO_get_blocks, | 674 | ocfs2_direct_IO_get_blocks, |
675 | ocfs2_dio_end_io); | 675 | ocfs2_dio_end_io); |
676 | 676 | ||
diff --git a/fs/ocfs2/buffer_head_io.c b/fs/ocfs2/buffer_head_io.c index d43d34a1dd31..21c808f752d8 100644 --- a/fs/ocfs2/buffer_head_io.c +++ b/fs/ocfs2/buffer_head_io.c | |||
@@ -368,7 +368,7 @@ int ocfs2_read_blocks(struct ocfs2_caching_info *ci, u64 block, int nr, | |||
368 | } | 368 | } |
369 | ocfs2_metadata_cache_io_unlock(ci); | 369 | ocfs2_metadata_cache_io_unlock(ci); |
370 | 370 | ||
371 | mlog(ML_BH_IO, "block=(%llu), nr=(%d), cached=%s, flags=0x%x\n", | 371 | mlog(ML_BH_IO, "block=(%llu), nr=(%d), cached=%s, flags=0x%x\n", |
372 | (unsigned long long)block, nr, | 372 | (unsigned long long)block, nr, |
373 | ((flags & OCFS2_BH_IGNORE_CACHE) || ignore_cache) ? "no" : "yes", | 373 | ((flags & OCFS2_BH_IGNORE_CACHE) || ignore_cache) ? "no" : "yes", |
374 | flags); | 374 | flags); |
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c index eda5b8bcddd5..5c9890006708 100644 --- a/fs/ocfs2/cluster/heartbeat.c +++ b/fs/ocfs2/cluster/heartbeat.c | |||
@@ -78,7 +78,7 @@ static struct o2hb_callback *hbcall_from_type(enum o2hb_callback_type type); | |||
78 | 78 | ||
79 | unsigned int o2hb_dead_threshold = O2HB_DEFAULT_DEAD_THRESHOLD; | 79 | unsigned int o2hb_dead_threshold = O2HB_DEFAULT_DEAD_THRESHOLD; |
80 | 80 | ||
81 | /* Only sets a new threshold if there are no active regions. | 81 | /* Only sets a new threshold if there are no active regions. |
82 | * | 82 | * |
83 | * No locking or otherwise interesting code is required for reading | 83 | * No locking or otherwise interesting code is required for reading |
84 | * o2hb_dead_threshold as it can't change once regions are active and | 84 | * o2hb_dead_threshold as it can't change once regions are active and |
@@ -170,7 +170,7 @@ static void o2hb_write_timeout(struct work_struct *work) | |||
170 | 170 | ||
171 | mlog(ML_ERROR, "Heartbeat write timeout to device %s after %u " | 171 | mlog(ML_ERROR, "Heartbeat write timeout to device %s after %u " |
172 | "milliseconds\n", reg->hr_dev_name, | 172 | "milliseconds\n", reg->hr_dev_name, |
173 | jiffies_to_msecs(jiffies - reg->hr_last_timeout_start)); | 173 | jiffies_to_msecs(jiffies - reg->hr_last_timeout_start)); |
174 | o2quo_disk_timeout(); | 174 | o2quo_disk_timeout(); |
175 | } | 175 | } |
176 | 176 | ||
@@ -624,7 +624,7 @@ static int o2hb_check_slot(struct o2hb_region *reg, | |||
624 | "seq %llu last %llu changed %u equal %u\n", | 624 | "seq %llu last %llu changed %u equal %u\n", |
625 | slot->ds_node_num, (long long)slot->ds_last_generation, | 625 | slot->ds_node_num, (long long)slot->ds_last_generation, |
626 | le32_to_cpu(hb_block->hb_cksum), | 626 | le32_to_cpu(hb_block->hb_cksum), |
627 | (unsigned long long)le64_to_cpu(hb_block->hb_seq), | 627 | (unsigned long long)le64_to_cpu(hb_block->hb_seq), |
628 | (unsigned long long)slot->ds_last_time, slot->ds_changed_samples, | 628 | (unsigned long long)slot->ds_last_time, slot->ds_changed_samples, |
629 | slot->ds_equal_samples); | 629 | slot->ds_equal_samples); |
630 | 630 | ||
diff --git a/fs/ocfs2/cluster/tcp.c b/fs/ocfs2/cluster/tcp.c index 334f231a422c..d8d0c65ac03c 100644 --- a/fs/ocfs2/cluster/tcp.c +++ b/fs/ocfs2/cluster/tcp.c | |||
@@ -485,7 +485,7 @@ static void o2net_set_nn_state(struct o2net_node *nn, | |||
485 | } | 485 | } |
486 | 486 | ||
487 | if (was_valid && !valid) { | 487 | if (was_valid && !valid) { |
488 | printk(KERN_INFO "o2net: no longer connected to " | 488 | printk(KERN_NOTICE "o2net: no longer connected to " |
489 | SC_NODEF_FMT "\n", SC_NODEF_ARGS(old_sc)); | 489 | SC_NODEF_FMT "\n", SC_NODEF_ARGS(old_sc)); |
490 | o2net_complete_nodes_nsw(nn); | 490 | o2net_complete_nodes_nsw(nn); |
491 | } | 491 | } |
@@ -493,7 +493,7 @@ static void o2net_set_nn_state(struct o2net_node *nn, | |||
493 | if (!was_valid && valid) { | 493 | if (!was_valid && valid) { |
494 | o2quo_conn_up(o2net_num_from_nn(nn)); | 494 | o2quo_conn_up(o2net_num_from_nn(nn)); |
495 | cancel_delayed_work(&nn->nn_connect_expired); | 495 | cancel_delayed_work(&nn->nn_connect_expired); |
496 | printk(KERN_INFO "o2net: %s " SC_NODEF_FMT "\n", | 496 | printk(KERN_NOTICE "o2net: %s " SC_NODEF_FMT "\n", |
497 | o2nm_this_node() > sc->sc_node->nd_num ? | 497 | o2nm_this_node() > sc->sc_node->nd_num ? |
498 | "connected to" : "accepted connection from", | 498 | "connected to" : "accepted connection from", |
499 | SC_NODEF_ARGS(sc)); | 499 | SC_NODEF_ARGS(sc)); |
@@ -930,7 +930,7 @@ static void o2net_sendpage(struct o2net_sock_container *sc, | |||
930 | cond_resched(); | 930 | cond_resched(); |
931 | continue; | 931 | continue; |
932 | } | 932 | } |
933 | mlog(ML_ERROR, "sendpage of size %zu to " SC_NODEF_FMT | 933 | mlog(ML_ERROR, "sendpage of size %zu to " SC_NODEF_FMT |
934 | " failed with %zd\n", size, SC_NODEF_ARGS(sc), ret); | 934 | " failed with %zd\n", size, SC_NODEF_ARGS(sc), ret); |
935 | o2net_ensure_shutdown(nn, sc, 0); | 935 | o2net_ensure_shutdown(nn, sc, 0); |
936 | break; | 936 | break; |
@@ -1476,14 +1476,14 @@ static void o2net_idle_timer(unsigned long data) | |||
1476 | 1476 | ||
1477 | do_gettimeofday(&now); | 1477 | do_gettimeofday(&now); |
1478 | 1478 | ||
1479 | printk(KERN_INFO "o2net: connection to " SC_NODEF_FMT " has been idle for %u.%u " | 1479 | printk(KERN_NOTICE "o2net: connection to " SC_NODEF_FMT " has been idle for %u.%u " |
1480 | "seconds, shutting it down.\n", SC_NODEF_ARGS(sc), | 1480 | "seconds, shutting it down.\n", SC_NODEF_ARGS(sc), |
1481 | o2net_idle_timeout() / 1000, | 1481 | o2net_idle_timeout() / 1000, |
1482 | o2net_idle_timeout() % 1000); | 1482 | o2net_idle_timeout() % 1000); |
1483 | mlog(ML_NOTICE, "here are some times that might help debug the " | 1483 | mlog(ML_NOTICE, "here are some times that might help debug the " |
1484 | "situation: (tmr %ld.%ld now %ld.%ld dr %ld.%ld adv " | 1484 | "situation: (tmr %ld.%ld now %ld.%ld dr %ld.%ld adv " |
1485 | "%ld.%ld:%ld.%ld func (%08x:%u) %ld.%ld:%ld.%ld)\n", | 1485 | "%ld.%ld:%ld.%ld func (%08x:%u) %ld.%ld:%ld.%ld)\n", |
1486 | sc->sc_tv_timer.tv_sec, (long) sc->sc_tv_timer.tv_usec, | 1486 | sc->sc_tv_timer.tv_sec, (long) sc->sc_tv_timer.tv_usec, |
1487 | now.tv_sec, (long) now.tv_usec, | 1487 | now.tv_sec, (long) now.tv_usec, |
1488 | sc->sc_tv_data_ready.tv_sec, (long) sc->sc_tv_data_ready.tv_usec, | 1488 | sc->sc_tv_data_ready.tv_sec, (long) sc->sc_tv_data_ready.tv_usec, |
1489 | sc->sc_tv_advance_start.tv_sec, | 1489 | sc->sc_tv_advance_start.tv_sec, |
diff --git a/fs/ocfs2/cluster/tcp_internal.h b/fs/ocfs2/cluster/tcp_internal.h index 8d58cfe410b1..96fa7ebc530c 100644 --- a/fs/ocfs2/cluster/tcp_internal.h +++ b/fs/ocfs2/cluster/tcp_internal.h | |||
@@ -32,10 +32,10 @@ | |||
32 | * on their number */ | 32 | * on their number */ |
33 | #define O2NET_QUORUM_DELAY_MS ((o2hb_dead_threshold + 2) * O2HB_REGION_TIMEOUT_MS) | 33 | #define O2NET_QUORUM_DELAY_MS ((o2hb_dead_threshold + 2) * O2HB_REGION_TIMEOUT_MS) |
34 | 34 | ||
35 | /* | 35 | /* |
36 | * This version number represents quite a lot, unfortunately. It not | 36 | * This version number represents quite a lot, unfortunately. It not |
37 | * only represents the raw network message protocol on the wire but also | 37 | * only represents the raw network message protocol on the wire but also |
38 | * locking semantics of the file system using the protocol. It should | 38 | * locking semantics of the file system using the protocol. It should |
39 | * be somewhere else, I'm sure, but right now it isn't. | 39 | * be somewhere else, I'm sure, but right now it isn't. |
40 | * | 40 | * |
41 | * With version 11, we separate out the filesystem locking portion. The | 41 | * With version 11, we separate out the filesystem locking portion. The |
diff --git a/fs/ocfs2/dlm/dlmapi.h b/fs/ocfs2/dlm/dlmapi.h index b5786a787fab..3cfa114aa391 100644 --- a/fs/ocfs2/dlm/dlmapi.h +++ b/fs/ocfs2/dlm/dlmapi.h | |||
@@ -95,7 +95,7 @@ const char *dlm_errname(enum dlm_status err); | |||
95 | mlog(ML_ERROR, "dlm status = %s\n", dlm_errname((st))); \ | 95 | mlog(ML_ERROR, "dlm status = %s\n", dlm_errname((st))); \ |
96 | } while (0) | 96 | } while (0) |
97 | 97 | ||
98 | #define DLM_LKSB_UNUSED1 0x01 | 98 | #define DLM_LKSB_UNUSED1 0x01 |
99 | #define DLM_LKSB_PUT_LVB 0x02 | 99 | #define DLM_LKSB_PUT_LVB 0x02 |
100 | #define DLM_LKSB_GET_LVB 0x04 | 100 | #define DLM_LKSB_GET_LVB 0x04 |
101 | #define DLM_LKSB_UNUSED2 0x08 | 101 | #define DLM_LKSB_UNUSED2 0x08 |
diff --git a/fs/ocfs2/dlm/dlmast.c b/fs/ocfs2/dlm/dlmast.c index 01cf8cc3d286..dccc439fa087 100644 --- a/fs/ocfs2/dlm/dlmast.c +++ b/fs/ocfs2/dlm/dlmast.c | |||
@@ -123,7 +123,7 @@ static void __dlm_queue_ast(struct dlm_ctxt *dlm, struct dlm_lock *lock) | |||
123 | dlm_lock_put(lock); | 123 | dlm_lock_put(lock); |
124 | /* free up the reserved bast that we are cancelling. | 124 | /* free up the reserved bast that we are cancelling. |
125 | * guaranteed that this will not be the last reserved | 125 | * guaranteed that this will not be the last reserved |
126 | * ast because *both* an ast and a bast were reserved | 126 | * ast because *both* an ast and a bast were reserved |
127 | * to get to this point. the res->spinlock will not be | 127 | * to get to this point. the res->spinlock will not be |
128 | * taken here */ | 128 | * taken here */ |
129 | dlm_lockres_release_ast(dlm, res); | 129 | dlm_lockres_release_ast(dlm, res); |
diff --git a/fs/ocfs2/dlm/dlmconvert.c b/fs/ocfs2/dlm/dlmconvert.c index ca96bce50e18..f283bce776b4 100644 --- a/fs/ocfs2/dlm/dlmconvert.c +++ b/fs/ocfs2/dlm/dlmconvert.c | |||
@@ -396,7 +396,7 @@ static enum dlm_status dlm_send_remote_convert_request(struct dlm_ctxt *dlm, | |||
396 | /* instead of logging the same network error over | 396 | /* instead of logging the same network error over |
397 | * and over, sleep here and wait for the heartbeat | 397 | * and over, sleep here and wait for the heartbeat |
398 | * to notice the node is dead. times out after 5s. */ | 398 | * to notice the node is dead. times out after 5s. */ |
399 | dlm_wait_for_node_death(dlm, res->owner, | 399 | dlm_wait_for_node_death(dlm, res->owner, |
400 | DLM_NODE_DEATH_WAIT_MAX); | 400 | DLM_NODE_DEATH_WAIT_MAX); |
401 | ret = DLM_RECOVERING; | 401 | ret = DLM_RECOVERING; |
402 | mlog(0, "node %u died so returning DLM_RECOVERING " | 402 | mlog(0, "node %u died so returning DLM_RECOVERING " |
diff --git a/fs/ocfs2/dlm/dlmdebug.c b/fs/ocfs2/dlm/dlmdebug.c index 42b0bad7a612..0cd24cf54396 100644 --- a/fs/ocfs2/dlm/dlmdebug.c +++ b/fs/ocfs2/dlm/dlmdebug.c | |||
@@ -102,7 +102,7 @@ void __dlm_print_one_lock_resource(struct dlm_lock_resource *res) | |||
102 | assert_spin_locked(&res->spinlock); | 102 | assert_spin_locked(&res->spinlock); |
103 | 103 | ||
104 | stringify_lockname(res->lockname.name, res->lockname.len, | 104 | stringify_lockname(res->lockname.name, res->lockname.len, |
105 | buf, sizeof(buf) - 1); | 105 | buf, sizeof(buf)); |
106 | printk("lockres: %s, owner=%u, state=%u\n", | 106 | printk("lockres: %s, owner=%u, state=%u\n", |
107 | buf, res->owner, res->state); | 107 | buf, res->owner, res->state); |
108 | printk(" last used: %lu, refcnt: %u, on purge list: %s\n", | 108 | printk(" last used: %lu, refcnt: %u, on purge list: %s\n", |
diff --git a/fs/ocfs2/dlm/dlmdomain.c b/fs/ocfs2/dlm/dlmdomain.c index 0334000676d3..988c9055fd4e 100644 --- a/fs/ocfs2/dlm/dlmdomain.c +++ b/fs/ocfs2/dlm/dlmdomain.c | |||
@@ -816,7 +816,7 @@ static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data, | |||
816 | } | 816 | } |
817 | 817 | ||
818 | /* Once the dlm ctxt is marked as leaving then we don't want | 818 | /* Once the dlm ctxt is marked as leaving then we don't want |
819 | * to be put in someone's domain map. | 819 | * to be put in someone's domain map. |
820 | * Also, explicitly disallow joining at certain troublesome | 820 | * Also, explicitly disallow joining at certain troublesome |
821 | * times (ie. during recovery). */ | 821 | * times (ie. during recovery). */ |
822 | if (dlm && dlm->dlm_state != DLM_CTXT_LEAVING) { | 822 | if (dlm && dlm->dlm_state != DLM_CTXT_LEAVING) { |
diff --git a/fs/ocfs2/dlm/dlmlock.c b/fs/ocfs2/dlm/dlmlock.c index 437698e9465f..733337772671 100644 --- a/fs/ocfs2/dlm/dlmlock.c +++ b/fs/ocfs2/dlm/dlmlock.c | |||
@@ -269,7 +269,7 @@ static enum dlm_status dlmlock_remote(struct dlm_ctxt *dlm, | |||
269 | } | 269 | } |
270 | dlm_revert_pending_lock(res, lock); | 270 | dlm_revert_pending_lock(res, lock); |
271 | dlm_lock_put(lock); | 271 | dlm_lock_put(lock); |
272 | } else if (dlm_is_recovery_lock(res->lockname.name, | 272 | } else if (dlm_is_recovery_lock(res->lockname.name, |
273 | res->lockname.len)) { | 273 | res->lockname.len)) { |
274 | /* special case for the $RECOVERY lock. | 274 | /* special case for the $RECOVERY lock. |
275 | * there will never be an AST delivered to put | 275 | * there will never be an AST delivered to put |
diff --git a/fs/ocfs2/dlm/dlmmaster.c b/fs/ocfs2/dlm/dlmmaster.c index 03ccf9a7b1f4..a659606dcb95 100644 --- a/fs/ocfs2/dlm/dlmmaster.c +++ b/fs/ocfs2/dlm/dlmmaster.c | |||
@@ -366,7 +366,7 @@ void dlm_hb_event_notify_attached(struct dlm_ctxt *dlm, int idx, int node_up) | |||
366 | struct dlm_master_list_entry *mle; | 366 | struct dlm_master_list_entry *mle; |
367 | 367 | ||
368 | assert_spin_locked(&dlm->spinlock); | 368 | assert_spin_locked(&dlm->spinlock); |
369 | 369 | ||
370 | list_for_each_entry(mle, &dlm->mle_hb_events, hb_events) { | 370 | list_for_each_entry(mle, &dlm->mle_hb_events, hb_events) { |
371 | if (node_up) | 371 | if (node_up) |
372 | dlm_mle_node_up(dlm, mle, NULL, idx); | 372 | dlm_mle_node_up(dlm, mle, NULL, idx); |
@@ -833,7 +833,7 @@ lookup: | |||
833 | __dlm_insert_mle(dlm, mle); | 833 | __dlm_insert_mle(dlm, mle); |
834 | 834 | ||
835 | /* still holding the dlm spinlock, check the recovery map | 835 | /* still holding the dlm spinlock, check the recovery map |
836 | * to see if there are any nodes that still need to be | 836 | * to see if there are any nodes that still need to be |
837 | * considered. these will not appear in the mle nodemap | 837 | * considered. these will not appear in the mle nodemap |
838 | * but they might own this lockres. wait on them. */ | 838 | * but they might own this lockres. wait on them. */ |
839 | bit = find_next_bit(dlm->recovery_map, O2NM_MAX_NODES, 0); | 839 | bit = find_next_bit(dlm->recovery_map, O2NM_MAX_NODES, 0); |
@@ -883,7 +883,7 @@ redo_request: | |||
883 | msleep(500); | 883 | msleep(500); |
884 | } | 884 | } |
885 | continue; | 885 | continue; |
886 | } | 886 | } |
887 | 887 | ||
888 | dlm_kick_recovery_thread(dlm); | 888 | dlm_kick_recovery_thread(dlm); |
889 | msleep(1000); | 889 | msleep(1000); |
@@ -939,8 +939,8 @@ wait: | |||
939 | res->lockname.name, blocked); | 939 | res->lockname.name, blocked); |
940 | if (++tries > 20) { | 940 | if (++tries > 20) { |
941 | mlog(ML_ERROR, "%s:%.*s: spinning on " | 941 | mlog(ML_ERROR, "%s:%.*s: spinning on " |
942 | "dlm_wait_for_lock_mastery, blocked=%d\n", | 942 | "dlm_wait_for_lock_mastery, blocked=%d\n", |
943 | dlm->name, res->lockname.len, | 943 | dlm->name, res->lockname.len, |
944 | res->lockname.name, blocked); | 944 | res->lockname.name, blocked); |
945 | dlm_print_one_lock_resource(res); | 945 | dlm_print_one_lock_resource(res); |
946 | dlm_print_one_mle(mle); | 946 | dlm_print_one_mle(mle); |
@@ -1029,7 +1029,7 @@ recheck: | |||
1029 | ret = dlm_restart_lock_mastery(dlm, res, mle, *blocked); | 1029 | ret = dlm_restart_lock_mastery(dlm, res, mle, *blocked); |
1030 | b = (mle->type == DLM_MLE_BLOCK); | 1030 | b = (mle->type == DLM_MLE_BLOCK); |
1031 | if ((*blocked && !b) || (!*blocked && b)) { | 1031 | if ((*blocked && !b) || (!*blocked && b)) { |
1032 | mlog(0, "%s:%.*s: status change: old=%d new=%d\n", | 1032 | mlog(0, "%s:%.*s: status change: old=%d new=%d\n", |
1033 | dlm->name, res->lockname.len, res->lockname.name, | 1033 | dlm->name, res->lockname.len, res->lockname.name, |
1034 | *blocked, b); | 1034 | *blocked, b); |
1035 | *blocked = b; | 1035 | *blocked = b; |
@@ -1602,7 +1602,7 @@ send_response: | |||
1602 | } | 1602 | } |
1603 | mlog(0, "%u is the owner of %.*s, cleaning everyone else\n", | 1603 | mlog(0, "%u is the owner of %.*s, cleaning everyone else\n", |
1604 | dlm->node_num, res->lockname.len, res->lockname.name); | 1604 | dlm->node_num, res->lockname.len, res->lockname.name); |
1605 | ret = dlm_dispatch_assert_master(dlm, res, 0, request->node_idx, | 1605 | ret = dlm_dispatch_assert_master(dlm, res, 0, request->node_idx, |
1606 | DLM_ASSERT_MASTER_MLE_CLEANUP); | 1606 | DLM_ASSERT_MASTER_MLE_CLEANUP); |
1607 | if (ret < 0) { | 1607 | if (ret < 0) { |
1608 | mlog(ML_ERROR, "failed to dispatch assert master work\n"); | 1608 | mlog(ML_ERROR, "failed to dispatch assert master work\n"); |
@@ -1701,7 +1701,7 @@ again: | |||
1701 | 1701 | ||
1702 | if (r & DLM_ASSERT_RESPONSE_REASSERT) { | 1702 | if (r & DLM_ASSERT_RESPONSE_REASSERT) { |
1703 | mlog(0, "%.*s: node %u create mles on other " | 1703 | mlog(0, "%.*s: node %u create mles on other " |
1704 | "nodes and requests a re-assert\n", | 1704 | "nodes and requests a re-assert\n", |
1705 | namelen, lockname, to); | 1705 | namelen, lockname, to); |
1706 | reassert = 1; | 1706 | reassert = 1; |
1707 | } | 1707 | } |
@@ -1812,7 +1812,7 @@ int dlm_assert_master_handler(struct o2net_msg *msg, u32 len, void *data, | |||
1812 | spin_unlock(&dlm->master_lock); | 1812 | spin_unlock(&dlm->master_lock); |
1813 | spin_unlock(&dlm->spinlock); | 1813 | spin_unlock(&dlm->spinlock); |
1814 | goto done; | 1814 | goto done; |
1815 | } | 1815 | } |
1816 | } | 1816 | } |
1817 | } | 1817 | } |
1818 | spin_unlock(&dlm->master_lock); | 1818 | spin_unlock(&dlm->master_lock); |
@@ -1883,7 +1883,7 @@ ok: | |||
1883 | int extra_ref = 0; | 1883 | int extra_ref = 0; |
1884 | int nn = -1; | 1884 | int nn = -1; |
1885 | int rr, err = 0; | 1885 | int rr, err = 0; |
1886 | 1886 | ||
1887 | spin_lock(&mle->spinlock); | 1887 | spin_lock(&mle->spinlock); |
1888 | if (mle->type == DLM_MLE_BLOCK || mle->type == DLM_MLE_MIGRATION) | 1888 | if (mle->type == DLM_MLE_BLOCK || mle->type == DLM_MLE_MIGRATION) |
1889 | extra_ref = 1; | 1889 | extra_ref = 1; |
@@ -1891,7 +1891,7 @@ ok: | |||
1891 | /* MASTER mle: if any bits set in the response map | 1891 | /* MASTER mle: if any bits set in the response map |
1892 | * then the calling node needs to re-assert to clear | 1892 | * then the calling node needs to re-assert to clear |
1893 | * up nodes that this node contacted */ | 1893 | * up nodes that this node contacted */ |
1894 | while ((nn = find_next_bit (mle->response_map, O2NM_MAX_NODES, | 1894 | while ((nn = find_next_bit (mle->response_map, O2NM_MAX_NODES, |
1895 | nn+1)) < O2NM_MAX_NODES) { | 1895 | nn+1)) < O2NM_MAX_NODES) { |
1896 | if (nn != dlm->node_num && nn != assert->node_idx) | 1896 | if (nn != dlm->node_num && nn != assert->node_idx) |
1897 | master_request = 1; | 1897 | master_request = 1; |
@@ -2002,7 +2002,7 @@ kill: | |||
2002 | __dlm_print_one_lock_resource(res); | 2002 | __dlm_print_one_lock_resource(res); |
2003 | spin_unlock(&res->spinlock); | 2003 | spin_unlock(&res->spinlock); |
2004 | spin_unlock(&dlm->spinlock); | 2004 | spin_unlock(&dlm->spinlock); |
2005 | *ret_data = (void *)res; | 2005 | *ret_data = (void *)res; |
2006 | dlm_put(dlm); | 2006 | dlm_put(dlm); |
2007 | return -EINVAL; | 2007 | return -EINVAL; |
2008 | } | 2008 | } |
@@ -2040,10 +2040,10 @@ int dlm_dispatch_assert_master(struct dlm_ctxt *dlm, | |||
2040 | item->u.am.request_from = request_from; | 2040 | item->u.am.request_from = request_from; |
2041 | item->u.am.flags = flags; | 2041 | item->u.am.flags = flags; |
2042 | 2042 | ||
2043 | if (ignore_higher) | 2043 | if (ignore_higher) |
2044 | mlog(0, "IGNORE HIGHER: %.*s\n", res->lockname.len, | 2044 | mlog(0, "IGNORE HIGHER: %.*s\n", res->lockname.len, |
2045 | res->lockname.name); | 2045 | res->lockname.name); |
2046 | 2046 | ||
2047 | spin_lock(&dlm->work_lock); | 2047 | spin_lock(&dlm->work_lock); |
2048 | list_add_tail(&item->list, &dlm->work_list); | 2048 | list_add_tail(&item->list, &dlm->work_list); |
2049 | spin_unlock(&dlm->work_lock); | 2049 | spin_unlock(&dlm->work_lock); |
@@ -2133,7 +2133,7 @@ put: | |||
2133 | * think that $RECOVERY is currently mastered by a dead node. If so, | 2133 | * think that $RECOVERY is currently mastered by a dead node. If so, |
2134 | * we wait a short time to allow that node to get notified by its own | 2134 | * we wait a short time to allow that node to get notified by its own |
2135 | * heartbeat stack, then check again. All $RECOVERY lock resources | 2135 | * heartbeat stack, then check again. All $RECOVERY lock resources |
2136 | * mastered by dead nodes are purged when the hearbeat callback is | 2136 | * mastered by dead nodes are purged when the hearbeat callback is |
2137 | * fired, so we can know for sure that it is safe to continue once | 2137 | * fired, so we can know for sure that it is safe to continue once |
2138 | * the node returns a live node or no node. */ | 2138 | * the node returns a live node or no node. */ |
2139 | static int dlm_pre_master_reco_lockres(struct dlm_ctxt *dlm, | 2139 | static int dlm_pre_master_reco_lockres(struct dlm_ctxt *dlm, |
@@ -2174,7 +2174,7 @@ static int dlm_pre_master_reco_lockres(struct dlm_ctxt *dlm, | |||
2174 | ret = -EAGAIN; | 2174 | ret = -EAGAIN; |
2175 | } | 2175 | } |
2176 | spin_unlock(&dlm->spinlock); | 2176 | spin_unlock(&dlm->spinlock); |
2177 | mlog(0, "%s: reco lock master is %u\n", dlm->name, | 2177 | mlog(0, "%s: reco lock master is %u\n", dlm->name, |
2178 | master); | 2178 | master); |
2179 | break; | 2179 | break; |
2180 | } | 2180 | } |
@@ -2602,7 +2602,7 @@ fail: | |||
2602 | 2602 | ||
2603 | mlog(0, "%s:%.*s: timed out during migration\n", | 2603 | mlog(0, "%s:%.*s: timed out during migration\n", |
2604 | dlm->name, res->lockname.len, res->lockname.name); | 2604 | dlm->name, res->lockname.len, res->lockname.name); |
2605 | /* avoid hang during shutdown when migrating lockres | 2605 | /* avoid hang during shutdown when migrating lockres |
2606 | * to a node which also goes down */ | 2606 | * to a node which also goes down */ |
2607 | if (dlm_is_node_dead(dlm, target)) { | 2607 | if (dlm_is_node_dead(dlm, target)) { |
2608 | mlog(0, "%s:%.*s: expected migration " | 2608 | mlog(0, "%s:%.*s: expected migration " |
@@ -2738,7 +2738,7 @@ static int dlm_migration_can_proceed(struct dlm_ctxt *dlm, | |||
2738 | can_proceed = !!(res->state & DLM_LOCK_RES_MIGRATING); | 2738 | can_proceed = !!(res->state & DLM_LOCK_RES_MIGRATING); |
2739 | spin_unlock(&res->spinlock); | 2739 | spin_unlock(&res->spinlock); |
2740 | 2740 | ||
2741 | /* target has died, so make the caller break out of the | 2741 | /* target has died, so make the caller break out of the |
2742 | * wait_event, but caller must recheck the domain_map */ | 2742 | * wait_event, but caller must recheck the domain_map */ |
2743 | spin_lock(&dlm->spinlock); | 2743 | spin_lock(&dlm->spinlock); |
2744 | if (!test_bit(mig_target, dlm->domain_map)) | 2744 | if (!test_bit(mig_target, dlm->domain_map)) |
diff --git a/fs/ocfs2/dlm/dlmrecovery.c b/fs/ocfs2/dlm/dlmrecovery.c index 2f9e4e19a4f2..344bcf90cbf4 100644 --- a/fs/ocfs2/dlm/dlmrecovery.c +++ b/fs/ocfs2/dlm/dlmrecovery.c | |||
@@ -1050,7 +1050,7 @@ static void dlm_move_reco_locks_to_list(struct dlm_ctxt *dlm, | |||
1050 | if (lock->ml.node == dead_node) { | 1050 | if (lock->ml.node == dead_node) { |
1051 | mlog(0, "AHA! there was " | 1051 | mlog(0, "AHA! there was " |
1052 | "a $RECOVERY lock for dead " | 1052 | "a $RECOVERY lock for dead " |
1053 | "node %u (%s)!\n", | 1053 | "node %u (%s)!\n", |
1054 | dead_node, dlm->name); | 1054 | dead_node, dlm->name); |
1055 | list_del_init(&lock->list); | 1055 | list_del_init(&lock->list); |
1056 | dlm_lock_put(lock); | 1056 | dlm_lock_put(lock); |
@@ -1164,6 +1164,39 @@ static void dlm_init_migratable_lockres(struct dlm_migratable_lockres *mres, | |||
1164 | mres->master = master; | 1164 | mres->master = master; |
1165 | } | 1165 | } |
1166 | 1166 | ||
1167 | static void dlm_prepare_lvb_for_migration(struct dlm_lock *lock, | ||
1168 | struct dlm_migratable_lockres *mres, | ||
1169 | int queue) | ||
1170 | { | ||
1171 | if (!lock->lksb) | ||
1172 | return; | ||
1173 | |||
1174 | /* Ignore lvb in all locks in the blocked list */ | ||
1175 | if (queue == DLM_BLOCKED_LIST) | ||
1176 | return; | ||
1177 | |||
1178 | /* Only consider lvbs in locks with granted EX or PR lock levels */ | ||
1179 | if (lock->ml.type != LKM_EXMODE && lock->ml.type != LKM_PRMODE) | ||
1180 | return; | ||
1181 | |||
1182 | if (dlm_lvb_is_empty(mres->lvb)) { | ||
1183 | memcpy(mres->lvb, lock->lksb->lvb, DLM_LVB_LEN); | ||
1184 | return; | ||
1185 | } | ||
1186 | |||
1187 | /* Ensure the lvb copied for migration matches in other valid locks */ | ||
1188 | if (!memcmp(mres->lvb, lock->lksb->lvb, DLM_LVB_LEN)) | ||
1189 | return; | ||
1190 | |||
1191 | mlog(ML_ERROR, "Mismatched lvb in lock cookie=%u:%llu, name=%.*s, " | ||
1192 | "node=%u\n", | ||
1193 | dlm_get_lock_cookie_node(be64_to_cpu(lock->ml.cookie)), | ||
1194 | dlm_get_lock_cookie_seq(be64_to_cpu(lock->ml.cookie)), | ||
1195 | lock->lockres->lockname.len, lock->lockres->lockname.name, | ||
1196 | lock->ml.node); | ||
1197 | dlm_print_one_lock_resource(lock->lockres); | ||
1198 | BUG(); | ||
1199 | } | ||
1167 | 1200 | ||
1168 | /* returns 1 if this lock fills the network structure, | 1201 | /* returns 1 if this lock fills the network structure, |
1169 | * 0 otherwise */ | 1202 | * 0 otherwise */ |
@@ -1181,20 +1214,7 @@ static int dlm_add_lock_to_array(struct dlm_lock *lock, | |||
1181 | ml->list = queue; | 1214 | ml->list = queue; |
1182 | if (lock->lksb) { | 1215 | if (lock->lksb) { |
1183 | ml->flags = lock->lksb->flags; | 1216 | ml->flags = lock->lksb->flags; |
1184 | /* send our current lvb */ | 1217 | dlm_prepare_lvb_for_migration(lock, mres, queue); |
1185 | if (ml->type == LKM_EXMODE || | ||
1186 | ml->type == LKM_PRMODE) { | ||
1187 | /* if it is already set, this had better be a PR | ||
1188 | * and it has to match */ | ||
1189 | if (!dlm_lvb_is_empty(mres->lvb) && | ||
1190 | (ml->type == LKM_EXMODE || | ||
1191 | memcmp(mres->lvb, lock->lksb->lvb, DLM_LVB_LEN))) { | ||
1192 | mlog(ML_ERROR, "mismatched lvbs!\n"); | ||
1193 | dlm_print_one_lock_resource(lock->lockres); | ||
1194 | BUG(); | ||
1195 | } | ||
1196 | memcpy(mres->lvb, lock->lksb->lvb, DLM_LVB_LEN); | ||
1197 | } | ||
1198 | } | 1218 | } |
1199 | ml->node = lock->ml.node; | 1219 | ml->node = lock->ml.node; |
1200 | mres->num_locks++; | 1220 | mres->num_locks++; |
@@ -1730,6 +1750,7 @@ static int dlm_process_recovery_data(struct dlm_ctxt *dlm, | |||
1730 | struct dlm_lock *lock = NULL; | 1750 | struct dlm_lock *lock = NULL; |
1731 | u8 from = O2NM_MAX_NODES; | 1751 | u8 from = O2NM_MAX_NODES; |
1732 | unsigned int added = 0; | 1752 | unsigned int added = 0; |
1753 | __be64 c; | ||
1733 | 1754 | ||
1734 | mlog(0, "running %d locks for this lockres\n", mres->num_locks); | 1755 | mlog(0, "running %d locks for this lockres\n", mres->num_locks); |
1735 | for (i=0; i<mres->num_locks; i++) { | 1756 | for (i=0; i<mres->num_locks; i++) { |
@@ -1777,19 +1798,48 @@ static int dlm_process_recovery_data(struct dlm_ctxt *dlm, | |||
1777 | /* lock is always created locally first, and | 1798 | /* lock is always created locally first, and |
1778 | * destroyed locally last. it must be on the list */ | 1799 | * destroyed locally last. it must be on the list */ |
1779 | if (!lock) { | 1800 | if (!lock) { |
1780 | __be64 c = ml->cookie; | 1801 | c = ml->cookie; |
1781 | mlog(ML_ERROR, "could not find local lock " | 1802 | mlog(ML_ERROR, "Could not find local lock " |
1782 | "with cookie %u:%llu!\n", | 1803 | "with cookie %u:%llu, node %u, " |
1804 | "list %u, flags 0x%x, type %d, " | ||
1805 | "conv %d, highest blocked %d\n", | ||
1783 | dlm_get_lock_cookie_node(be64_to_cpu(c)), | 1806 | dlm_get_lock_cookie_node(be64_to_cpu(c)), |
1784 | dlm_get_lock_cookie_seq(be64_to_cpu(c))); | 1807 | dlm_get_lock_cookie_seq(be64_to_cpu(c)), |
1808 | ml->node, ml->list, ml->flags, ml->type, | ||
1809 | ml->convert_type, ml->highest_blocked); | ||
1810 | __dlm_print_one_lock_resource(res); | ||
1811 | BUG(); | ||
1812 | } | ||
1813 | |||
1814 | if (lock->ml.node != ml->node) { | ||
1815 | c = lock->ml.cookie; | ||
1816 | mlog(ML_ERROR, "Mismatched node# in lock " | ||
1817 | "cookie %u:%llu, name %.*s, node %u\n", | ||
1818 | dlm_get_lock_cookie_node(be64_to_cpu(c)), | ||
1819 | dlm_get_lock_cookie_seq(be64_to_cpu(c)), | ||
1820 | res->lockname.len, res->lockname.name, | ||
1821 | lock->ml.node); | ||
1822 | c = ml->cookie; | ||
1823 | mlog(ML_ERROR, "Migrate lock cookie %u:%llu, " | ||
1824 | "node %u, list %u, flags 0x%x, type %d, " | ||
1825 | "conv %d, highest blocked %d\n", | ||
1826 | dlm_get_lock_cookie_node(be64_to_cpu(c)), | ||
1827 | dlm_get_lock_cookie_seq(be64_to_cpu(c)), | ||
1828 | ml->node, ml->list, ml->flags, ml->type, | ||
1829 | ml->convert_type, ml->highest_blocked); | ||
1785 | __dlm_print_one_lock_resource(res); | 1830 | __dlm_print_one_lock_resource(res); |
1786 | BUG(); | 1831 | BUG(); |
1787 | } | 1832 | } |
1788 | BUG_ON(lock->ml.node != ml->node); | ||
1789 | 1833 | ||
1790 | if (tmpq != queue) { | 1834 | if (tmpq != queue) { |
1791 | mlog(0, "lock was on %u instead of %u for %.*s\n", | 1835 | c = ml->cookie; |
1792 | j, ml->list, res->lockname.len, res->lockname.name); | 1836 | mlog(0, "Lock cookie %u:%llu was on list %u " |
1837 | "instead of list %u for %.*s\n", | ||
1838 | dlm_get_lock_cookie_node(be64_to_cpu(c)), | ||
1839 | dlm_get_lock_cookie_seq(be64_to_cpu(c)), | ||
1840 | j, ml->list, res->lockname.len, | ||
1841 | res->lockname.name); | ||
1842 | __dlm_print_one_lock_resource(res); | ||
1793 | spin_unlock(&res->spinlock); | 1843 | spin_unlock(&res->spinlock); |
1794 | continue; | 1844 | continue; |
1795 | } | 1845 | } |
@@ -1839,7 +1889,7 @@ static int dlm_process_recovery_data(struct dlm_ctxt *dlm, | |||
1839 | * the lvb. */ | 1889 | * the lvb. */ |
1840 | memcpy(res->lvb, mres->lvb, DLM_LVB_LEN); | 1890 | memcpy(res->lvb, mres->lvb, DLM_LVB_LEN); |
1841 | } else { | 1891 | } else { |
1842 | /* otherwise, the node is sending its | 1892 | /* otherwise, the node is sending its |
1843 | * most recent valid lvb info */ | 1893 | * most recent valid lvb info */ |
1844 | BUG_ON(ml->type != LKM_EXMODE && | 1894 | BUG_ON(ml->type != LKM_EXMODE && |
1845 | ml->type != LKM_PRMODE); | 1895 | ml->type != LKM_PRMODE); |
@@ -1886,7 +1936,7 @@ skip_lvb: | |||
1886 | spin_lock(&res->spinlock); | 1936 | spin_lock(&res->spinlock); |
1887 | list_for_each_entry(lock, queue, list) { | 1937 | list_for_each_entry(lock, queue, list) { |
1888 | if (lock->ml.cookie == ml->cookie) { | 1938 | if (lock->ml.cookie == ml->cookie) { |
1889 | __be64 c = lock->ml.cookie; | 1939 | c = lock->ml.cookie; |
1890 | mlog(ML_ERROR, "%s:%.*s: %u:%llu: lock already " | 1940 | mlog(ML_ERROR, "%s:%.*s: %u:%llu: lock already " |
1891 | "exists on this lockres!\n", dlm->name, | 1941 | "exists on this lockres!\n", dlm->name, |
1892 | res->lockname.len, res->lockname.name, | 1942 | res->lockname.len, res->lockname.name, |
@@ -2114,7 +2164,7 @@ static void dlm_revalidate_lvb(struct dlm_ctxt *dlm, | |||
2114 | assert_spin_locked(&res->spinlock); | 2164 | assert_spin_locked(&res->spinlock); |
2115 | 2165 | ||
2116 | if (res->owner == dlm->node_num) | 2166 | if (res->owner == dlm->node_num) |
2117 | /* if this node owned the lockres, and if the dead node | 2167 | /* if this node owned the lockres, and if the dead node |
2118 | * had an EX when he died, blank out the lvb */ | 2168 | * had an EX when he died, blank out the lvb */ |
2119 | search_node = dead_node; | 2169 | search_node = dead_node; |
2120 | else { | 2170 | else { |
@@ -2152,7 +2202,7 @@ static void dlm_free_dead_locks(struct dlm_ctxt *dlm, | |||
2152 | 2202 | ||
2153 | /* this node is the lockres master: | 2203 | /* this node is the lockres master: |
2154 | * 1) remove any stale locks for the dead node | 2204 | * 1) remove any stale locks for the dead node |
2155 | * 2) if the dead node had an EX when he died, blank out the lvb | 2205 | * 2) if the dead node had an EX when he died, blank out the lvb |
2156 | */ | 2206 | */ |
2157 | assert_spin_locked(&dlm->spinlock); | 2207 | assert_spin_locked(&dlm->spinlock); |
2158 | assert_spin_locked(&res->spinlock); | 2208 | assert_spin_locked(&res->spinlock); |
@@ -2193,7 +2243,12 @@ static void dlm_free_dead_locks(struct dlm_ctxt *dlm, | |||
2193 | mlog(0, "%s:%.*s: freed %u locks for dead node %u, " | 2243 | mlog(0, "%s:%.*s: freed %u locks for dead node %u, " |
2194 | "dropping ref from lockres\n", dlm->name, | 2244 | "dropping ref from lockres\n", dlm->name, |
2195 | res->lockname.len, res->lockname.name, freed, dead_node); | 2245 | res->lockname.len, res->lockname.name, freed, dead_node); |
2196 | BUG_ON(!test_bit(dead_node, res->refmap)); | 2246 | if(!test_bit(dead_node, res->refmap)) { |
2247 | mlog(ML_ERROR, "%s:%.*s: freed %u locks for dead node %u, " | ||
2248 | "but ref was not set\n", dlm->name, | ||
2249 | res->lockname.len, res->lockname.name, freed, dead_node); | ||
2250 | __dlm_print_one_lock_resource(res); | ||
2251 | } | ||
2197 | dlm_lockres_clear_refmap_bit(dead_node, res); | 2252 | dlm_lockres_clear_refmap_bit(dead_node, res); |
2198 | } else if (test_bit(dead_node, res->refmap)) { | 2253 | } else if (test_bit(dead_node, res->refmap)) { |
2199 | mlog(0, "%s:%.*s: dead node %u had a ref, but had " | 2254 | mlog(0, "%s:%.*s: dead node %u had a ref, but had " |
@@ -2260,7 +2315,7 @@ static void dlm_do_local_recovery_cleanup(struct dlm_ctxt *dlm, u8 dead_node) | |||
2260 | } | 2315 | } |
2261 | spin_unlock(&res->spinlock); | 2316 | spin_unlock(&res->spinlock); |
2262 | continue; | 2317 | continue; |
2263 | } | 2318 | } |
2264 | spin_lock(&res->spinlock); | 2319 | spin_lock(&res->spinlock); |
2265 | /* zero the lvb if necessary */ | 2320 | /* zero the lvb if necessary */ |
2266 | dlm_revalidate_lvb(dlm, res, dead_node); | 2321 | dlm_revalidate_lvb(dlm, res, dead_node); |
@@ -2411,7 +2466,7 @@ static void dlm_reco_unlock_ast(void *astdata, enum dlm_status st) | |||
2411 | * this function on each node racing to become the recovery | 2466 | * this function on each node racing to become the recovery |
2412 | * master will not stop attempting this until either: | 2467 | * master will not stop attempting this until either: |
2413 | * a) this node gets the EX (and becomes the recovery master), | 2468 | * a) this node gets the EX (and becomes the recovery master), |
2414 | * or b) dlm->reco.new_master gets set to some nodenum | 2469 | * or b) dlm->reco.new_master gets set to some nodenum |
2415 | * != O2NM_INVALID_NODE_NUM (another node will do the reco). | 2470 | * != O2NM_INVALID_NODE_NUM (another node will do the reco). |
2416 | * so each time a recovery master is needed, the entire cluster | 2471 | * so each time a recovery master is needed, the entire cluster |
2417 | * will sync at this point. if the new master dies, that will | 2472 | * will sync at this point. if the new master dies, that will |
@@ -2424,7 +2479,7 @@ static int dlm_pick_recovery_master(struct dlm_ctxt *dlm) | |||
2424 | 2479 | ||
2425 | mlog(0, "starting recovery of %s at %lu, dead=%u, this=%u\n", | 2480 | mlog(0, "starting recovery of %s at %lu, dead=%u, this=%u\n", |
2426 | dlm->name, jiffies, dlm->reco.dead_node, dlm->node_num); | 2481 | dlm->name, jiffies, dlm->reco.dead_node, dlm->node_num); |
2427 | again: | 2482 | again: |
2428 | memset(&lksb, 0, sizeof(lksb)); | 2483 | memset(&lksb, 0, sizeof(lksb)); |
2429 | 2484 | ||
2430 | ret = dlmlock(dlm, LKM_EXMODE, &lksb, LKM_NOQUEUE|LKM_RECOVERY, | 2485 | ret = dlmlock(dlm, LKM_EXMODE, &lksb, LKM_NOQUEUE|LKM_RECOVERY, |
@@ -2437,8 +2492,8 @@ again: | |||
2437 | if (ret == DLM_NORMAL) { | 2492 | if (ret == DLM_NORMAL) { |
2438 | mlog(0, "dlm=%s dlmlock says I got it (this=%u)\n", | 2493 | mlog(0, "dlm=%s dlmlock says I got it (this=%u)\n", |
2439 | dlm->name, dlm->node_num); | 2494 | dlm->name, dlm->node_num); |
2440 | 2495 | ||
2441 | /* got the EX lock. check to see if another node | 2496 | /* got the EX lock. check to see if another node |
2442 | * just became the reco master */ | 2497 | * just became the reco master */ |
2443 | if (dlm_reco_master_ready(dlm)) { | 2498 | if (dlm_reco_master_ready(dlm)) { |
2444 | mlog(0, "%s: got reco EX lock, but %u will " | 2499 | mlog(0, "%s: got reco EX lock, but %u will " |
@@ -2451,12 +2506,12 @@ again: | |||
2451 | /* see if recovery was already finished elsewhere */ | 2506 | /* see if recovery was already finished elsewhere */ |
2452 | spin_lock(&dlm->spinlock); | 2507 | spin_lock(&dlm->spinlock); |
2453 | if (dlm->reco.dead_node == O2NM_INVALID_NODE_NUM) { | 2508 | if (dlm->reco.dead_node == O2NM_INVALID_NODE_NUM) { |
2454 | status = -EINVAL; | 2509 | status = -EINVAL; |
2455 | mlog(0, "%s: got reco EX lock, but " | 2510 | mlog(0, "%s: got reco EX lock, but " |
2456 | "node got recovered already\n", dlm->name); | 2511 | "node got recovered already\n", dlm->name); |
2457 | if (dlm->reco.new_master != O2NM_INVALID_NODE_NUM) { | 2512 | if (dlm->reco.new_master != O2NM_INVALID_NODE_NUM) { |
2458 | mlog(ML_ERROR, "%s: new master is %u " | 2513 | mlog(ML_ERROR, "%s: new master is %u " |
2459 | "but no dead node!\n", | 2514 | "but no dead node!\n", |
2460 | dlm->name, dlm->reco.new_master); | 2515 | dlm->name, dlm->reco.new_master); |
2461 | BUG(); | 2516 | BUG(); |
2462 | } | 2517 | } |
@@ -2468,7 +2523,7 @@ again: | |||
2468 | * set the master and send the messages to begin recovery */ | 2523 | * set the master and send the messages to begin recovery */ |
2469 | if (!status) { | 2524 | if (!status) { |
2470 | mlog(0, "%s: dead=%u, this=%u, sending " | 2525 | mlog(0, "%s: dead=%u, this=%u, sending " |
2471 | "begin_reco now\n", dlm->name, | 2526 | "begin_reco now\n", dlm->name, |
2472 | dlm->reco.dead_node, dlm->node_num); | 2527 | dlm->reco.dead_node, dlm->node_num); |
2473 | status = dlm_send_begin_reco_message(dlm, | 2528 | status = dlm_send_begin_reco_message(dlm, |
2474 | dlm->reco.dead_node); | 2529 | dlm->reco.dead_node); |
@@ -2501,7 +2556,7 @@ again: | |||
2501 | mlog(0, "dlm=%s dlmlock says another node got it (this=%u)\n", | 2556 | mlog(0, "dlm=%s dlmlock says another node got it (this=%u)\n", |
2502 | dlm->name, dlm->node_num); | 2557 | dlm->name, dlm->node_num); |
2503 | /* another node is master. wait on | 2558 | /* another node is master. wait on |
2504 | * reco.new_master != O2NM_INVALID_NODE_NUM | 2559 | * reco.new_master != O2NM_INVALID_NODE_NUM |
2505 | * for at most one second */ | 2560 | * for at most one second */ |
2506 | wait_event_timeout(dlm->dlm_reco_thread_wq, | 2561 | wait_event_timeout(dlm->dlm_reco_thread_wq, |
2507 | dlm_reco_master_ready(dlm), | 2562 | dlm_reco_master_ready(dlm), |
@@ -2589,7 +2644,13 @@ retry: | |||
2589 | "begin reco msg (%d)\n", dlm->name, nodenum, ret); | 2644 | "begin reco msg (%d)\n", dlm->name, nodenum, ret); |
2590 | ret = 0; | 2645 | ret = 0; |
2591 | } | 2646 | } |
2592 | if (ret == -EAGAIN) { | 2647 | |
2648 | /* | ||
2649 | * Prior to commit aad1b15310b9bcd59fa81ab8f2b1513b59553ea8, | ||
2650 | * dlm_begin_reco_handler() returned EAGAIN and not -EAGAIN. | ||
2651 | * We are handling both for compatibility reasons. | ||
2652 | */ | ||
2653 | if (ret == -EAGAIN || ret == EAGAIN) { | ||
2593 | mlog(0, "%s: trying to start recovery of node " | 2654 | mlog(0, "%s: trying to start recovery of node " |
2594 | "%u, but node %u is waiting for last recovery " | 2655 | "%u, but node %u is waiting for last recovery " |
2595 | "to complete, backoff for a bit\n", dlm->name, | 2656 | "to complete, backoff for a bit\n", dlm->name, |
@@ -2599,7 +2660,7 @@ retry: | |||
2599 | } | 2660 | } |
2600 | if (ret < 0) { | 2661 | if (ret < 0) { |
2601 | struct dlm_lock_resource *res; | 2662 | struct dlm_lock_resource *res; |
2602 | /* this is now a serious problem, possibly ENOMEM | 2663 | /* this is now a serious problem, possibly ENOMEM |
2603 | * in the network stack. must retry */ | 2664 | * in the network stack. must retry */ |
2604 | mlog_errno(ret); | 2665 | mlog_errno(ret); |
2605 | mlog(ML_ERROR, "begin reco of dlm %s to node %u " | 2666 | mlog(ML_ERROR, "begin reco of dlm %s to node %u " |
@@ -2612,7 +2673,7 @@ retry: | |||
2612 | } else { | 2673 | } else { |
2613 | mlog(ML_ERROR, "recovery lock not found\n"); | 2674 | mlog(ML_ERROR, "recovery lock not found\n"); |
2614 | } | 2675 | } |
2615 | /* sleep for a bit in hopes that we can avoid | 2676 | /* sleep for a bit in hopes that we can avoid |
2616 | * another ENOMEM */ | 2677 | * another ENOMEM */ |
2617 | msleep(100); | 2678 | msleep(100); |
2618 | goto retry; | 2679 | goto retry; |
@@ -2664,7 +2725,7 @@ int dlm_begin_reco_handler(struct o2net_msg *msg, u32 len, void *data, | |||
2664 | } | 2725 | } |
2665 | if (dlm->reco.dead_node != O2NM_INVALID_NODE_NUM) { | 2726 | if (dlm->reco.dead_node != O2NM_INVALID_NODE_NUM) { |
2666 | mlog(ML_NOTICE, "%s: dead_node previously set to %u, " | 2727 | mlog(ML_NOTICE, "%s: dead_node previously set to %u, " |
2667 | "node %u changing it to %u\n", dlm->name, | 2728 | "node %u changing it to %u\n", dlm->name, |
2668 | dlm->reco.dead_node, br->node_idx, br->dead_node); | 2729 | dlm->reco.dead_node, br->node_idx, br->dead_node); |
2669 | } | 2730 | } |
2670 | dlm_set_reco_master(dlm, br->node_idx); | 2731 | dlm_set_reco_master(dlm, br->node_idx); |
@@ -2730,8 +2791,8 @@ stage2: | |||
2730 | if (ret < 0) { | 2791 | if (ret < 0) { |
2731 | mlog_errno(ret); | 2792 | mlog_errno(ret); |
2732 | if (dlm_is_host_down(ret)) { | 2793 | if (dlm_is_host_down(ret)) { |
2733 | /* this has no effect on this recovery | 2794 | /* this has no effect on this recovery |
2734 | * session, so set the status to zero to | 2795 | * session, so set the status to zero to |
2735 | * finish out the last recovery */ | 2796 | * finish out the last recovery */ |
2736 | mlog(ML_ERROR, "node %u went down after this " | 2797 | mlog(ML_ERROR, "node %u went down after this " |
2737 | "node finished recovery.\n", nodenum); | 2798 | "node finished recovery.\n", nodenum); |
@@ -2768,7 +2829,7 @@ int dlm_finalize_reco_handler(struct o2net_msg *msg, u32 len, void *data, | |||
2768 | mlog(0, "%s: node %u finalizing recovery stage%d of " | 2829 | mlog(0, "%s: node %u finalizing recovery stage%d of " |
2769 | "node %u (%u:%u)\n", dlm->name, fr->node_idx, stage, | 2830 | "node %u (%u:%u)\n", dlm->name, fr->node_idx, stage, |
2770 | fr->dead_node, dlm->reco.dead_node, dlm->reco.new_master); | 2831 | fr->dead_node, dlm->reco.dead_node, dlm->reco.new_master); |
2771 | 2832 | ||
2772 | spin_lock(&dlm->spinlock); | 2833 | spin_lock(&dlm->spinlock); |
2773 | 2834 | ||
2774 | if (dlm->reco.new_master != fr->node_idx) { | 2835 | if (dlm->reco.new_master != fr->node_idx) { |
diff --git a/fs/ocfs2/dlm/dlmunlock.c b/fs/ocfs2/dlm/dlmunlock.c index 00f53b2aea76..49e29ecd0201 100644 --- a/fs/ocfs2/dlm/dlmunlock.c +++ b/fs/ocfs2/dlm/dlmunlock.c | |||
@@ -190,8 +190,8 @@ static enum dlm_status dlmunlock_common(struct dlm_ctxt *dlm, | |||
190 | actions &= ~(DLM_UNLOCK_REMOVE_LOCK| | 190 | actions &= ~(DLM_UNLOCK_REMOVE_LOCK| |
191 | DLM_UNLOCK_REGRANT_LOCK| | 191 | DLM_UNLOCK_REGRANT_LOCK| |
192 | DLM_UNLOCK_CLEAR_CONVERT_TYPE); | 192 | DLM_UNLOCK_CLEAR_CONVERT_TYPE); |
193 | } else if (status == DLM_RECOVERING || | 193 | } else if (status == DLM_RECOVERING || |
194 | status == DLM_MIGRATING || | 194 | status == DLM_MIGRATING || |
195 | status == DLM_FORWARD) { | 195 | status == DLM_FORWARD) { |
196 | /* must clear the actions because this unlock | 196 | /* must clear the actions because this unlock |
197 | * is about to be retried. cannot free or do | 197 | * is about to be retried. cannot free or do |
@@ -661,14 +661,14 @@ retry: | |||
661 | if (call_ast) { | 661 | if (call_ast) { |
662 | mlog(0, "calling unlockast(%p, %d)\n", data, status); | 662 | mlog(0, "calling unlockast(%p, %d)\n", data, status); |
663 | if (is_master) { | 663 | if (is_master) { |
664 | /* it is possible that there is one last bast | 664 | /* it is possible that there is one last bast |
665 | * pending. make sure it is flushed, then | 665 | * pending. make sure it is flushed, then |
666 | * call the unlockast. | 666 | * call the unlockast. |
667 | * not an issue if this is a mastered remotely, | 667 | * not an issue if this is a mastered remotely, |
668 | * since this lock has been removed from the | 668 | * since this lock has been removed from the |
669 | * lockres queues and cannot be found. */ | 669 | * lockres queues and cannot be found. */ |
670 | dlm_kick_thread(dlm, NULL); | 670 | dlm_kick_thread(dlm, NULL); |
671 | wait_event(dlm->ast_wq, | 671 | wait_event(dlm->ast_wq, |
672 | dlm_lock_basts_flushed(dlm, lock)); | 672 | dlm_lock_basts_flushed(dlm, lock)); |
673 | } | 673 | } |
674 | (*unlockast)(data, status); | 674 | (*unlockast)(data, status); |
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c index c5e4a49e3a12..e044019cb3b1 100644 --- a/fs/ocfs2/dlmglue.c +++ b/fs/ocfs2/dlmglue.c | |||
@@ -875,6 +875,14 @@ static inline void ocfs2_generic_handle_convert_action(struct ocfs2_lock_res *lo | |||
875 | lockres_or_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH); | 875 | lockres_or_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH); |
876 | 876 | ||
877 | lockres->l_level = lockres->l_requested; | 877 | lockres->l_level = lockres->l_requested; |
878 | |||
879 | /* | ||
880 | * We set the OCFS2_LOCK_UPCONVERT_FINISHING flag before clearing | ||
881 | * the OCFS2_LOCK_BUSY flag to prevent the dc thread from | ||
882 | * downconverting the lock before the upconvert has fully completed. | ||
883 | */ | ||
884 | lockres_or_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING); | ||
885 | |||
878 | lockres_clear_flags(lockres, OCFS2_LOCK_BUSY); | 886 | lockres_clear_flags(lockres, OCFS2_LOCK_BUSY); |
879 | 887 | ||
880 | mlog_exit_void(); | 888 | mlog_exit_void(); |
@@ -907,8 +915,6 @@ static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres, | |||
907 | 915 | ||
908 | assert_spin_locked(&lockres->l_lock); | 916 | assert_spin_locked(&lockres->l_lock); |
909 | 917 | ||
910 | lockres_or_flags(lockres, OCFS2_LOCK_BLOCKED); | ||
911 | |||
912 | if (level > lockres->l_blocking) { | 918 | if (level > lockres->l_blocking) { |
913 | /* only schedule a downconvert if we haven't already scheduled | 919 | /* only schedule a downconvert if we haven't already scheduled |
914 | * one that goes low enough to satisfy the level we're | 920 | * one that goes low enough to satisfy the level we're |
@@ -921,6 +927,9 @@ static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres, | |||
921 | lockres->l_blocking = level; | 927 | lockres->l_blocking = level; |
922 | } | 928 | } |
923 | 929 | ||
930 | if (needs_downconvert) | ||
931 | lockres_or_flags(lockres, OCFS2_LOCK_BLOCKED); | ||
932 | |||
924 | mlog_exit(needs_downconvert); | 933 | mlog_exit(needs_downconvert); |
925 | return needs_downconvert; | 934 | return needs_downconvert; |
926 | } | 935 | } |
@@ -1133,6 +1142,7 @@ static inline void ocfs2_recover_from_dlm_error(struct ocfs2_lock_res *lockres, | |||
1133 | mlog_entry_void(); | 1142 | mlog_entry_void(); |
1134 | spin_lock_irqsave(&lockres->l_lock, flags); | 1143 | spin_lock_irqsave(&lockres->l_lock, flags); |
1135 | lockres_clear_flags(lockres, OCFS2_LOCK_BUSY); | 1144 | lockres_clear_flags(lockres, OCFS2_LOCK_BUSY); |
1145 | lockres_clear_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING); | ||
1136 | if (convert) | 1146 | if (convert) |
1137 | lockres->l_action = OCFS2_AST_INVALID; | 1147 | lockres->l_action = OCFS2_AST_INVALID; |
1138 | else | 1148 | else |
@@ -1323,13 +1333,13 @@ static int __ocfs2_cluster_lock(struct ocfs2_super *osb, | |||
1323 | again: | 1333 | again: |
1324 | wait = 0; | 1334 | wait = 0; |
1325 | 1335 | ||
1336 | spin_lock_irqsave(&lockres->l_lock, flags); | ||
1337 | |||
1326 | if (catch_signals && signal_pending(current)) { | 1338 | if (catch_signals && signal_pending(current)) { |
1327 | ret = -ERESTARTSYS; | 1339 | ret = -ERESTARTSYS; |
1328 | goto out; | 1340 | goto unlock; |
1329 | } | 1341 | } |
1330 | 1342 | ||
1331 | spin_lock_irqsave(&lockres->l_lock, flags); | ||
1332 | |||
1333 | mlog_bug_on_msg(lockres->l_flags & OCFS2_LOCK_FREEING, | 1343 | mlog_bug_on_msg(lockres->l_flags & OCFS2_LOCK_FREEING, |
1334 | "Cluster lock called on freeing lockres %s! flags " | 1344 | "Cluster lock called on freeing lockres %s! flags " |
1335 | "0x%lx\n", lockres->l_name, lockres->l_flags); | 1345 | "0x%lx\n", lockres->l_name, lockres->l_flags); |
@@ -1346,6 +1356,25 @@ again: | |||
1346 | goto unlock; | 1356 | goto unlock; |
1347 | } | 1357 | } |
1348 | 1358 | ||
1359 | if (lockres->l_flags & OCFS2_LOCK_UPCONVERT_FINISHING) { | ||
1360 | /* | ||
1361 | * We've upconverted. If the lock now has a level we can | ||
1362 | * work with, we take it. If, however, the lock is not at the | ||
1363 | * required level, we go thru the full cycle. One way this could | ||
1364 | * happen is if a process requesting an upconvert to PR is | ||
1365 | * closely followed by another requesting upconvert to an EX. | ||
1366 | * If the process requesting EX lands here, we want it to | ||
1367 | * continue attempting to upconvert and let the process | ||
1368 | * requesting PR take the lock. | ||
1369 | * If multiple processes request upconvert to PR, the first one | ||
1370 | * here will take the lock. The others will have to go thru the | ||
1371 | * OCFS2_LOCK_BLOCKED check to ensure that there is no pending | ||
1372 | * downconvert request. | ||
1373 | */ | ||
1374 | if (level <= lockres->l_level) | ||
1375 | goto update_holders; | ||
1376 | } | ||
1377 | |||
1349 | if (lockres->l_flags & OCFS2_LOCK_BLOCKED && | 1378 | if (lockres->l_flags & OCFS2_LOCK_BLOCKED && |
1350 | !ocfs2_may_continue_on_blocked_lock(lockres, level)) { | 1379 | !ocfs2_may_continue_on_blocked_lock(lockres, level)) { |
1351 | /* is the lock is currently blocked on behalf of | 1380 | /* is the lock is currently blocked on behalf of |
@@ -1416,11 +1445,14 @@ again: | |||
1416 | goto again; | 1445 | goto again; |
1417 | } | 1446 | } |
1418 | 1447 | ||
1448 | update_holders: | ||
1419 | /* Ok, if we get here then we're good to go. */ | 1449 | /* Ok, if we get here then we're good to go. */ |
1420 | ocfs2_inc_holders(lockres, level); | 1450 | ocfs2_inc_holders(lockres, level); |
1421 | 1451 | ||
1422 | ret = 0; | 1452 | ret = 0; |
1423 | unlock: | 1453 | unlock: |
1454 | lockres_clear_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING); | ||
1455 | |||
1424 | spin_unlock_irqrestore(&lockres->l_lock, flags); | 1456 | spin_unlock_irqrestore(&lockres->l_lock, flags); |
1425 | out: | 1457 | out: |
1426 | /* | 1458 | /* |
@@ -3155,7 +3187,7 @@ out: | |||
3155 | /* Mark the lockres as being dropped. It will no longer be | 3187 | /* Mark the lockres as being dropped. It will no longer be |
3156 | * queued if blocking, but we still may have to wait on it | 3188 | * queued if blocking, but we still may have to wait on it |
3157 | * being dequeued from the downconvert thread before we can consider | 3189 | * being dequeued from the downconvert thread before we can consider |
3158 | * it safe to drop. | 3190 | * it safe to drop. |
3159 | * | 3191 | * |
3160 | * You can *not* attempt to call cluster_lock on this lockres anymore. */ | 3192 | * You can *not* attempt to call cluster_lock on this lockres anymore. */ |
3161 | void ocfs2_mark_lockres_freeing(struct ocfs2_lock_res *lockres) | 3193 | void ocfs2_mark_lockres_freeing(struct ocfs2_lock_res *lockres) |
@@ -3352,6 +3384,7 @@ static int ocfs2_unblock_lock(struct ocfs2_super *osb, | |||
3352 | unsigned long flags; | 3384 | unsigned long flags; |
3353 | int blocking; | 3385 | int blocking; |
3354 | int new_level; | 3386 | int new_level; |
3387 | int level; | ||
3355 | int ret = 0; | 3388 | int ret = 0; |
3356 | int set_lvb = 0; | 3389 | int set_lvb = 0; |
3357 | unsigned int gen; | 3390 | unsigned int gen; |
@@ -3360,9 +3393,17 @@ static int ocfs2_unblock_lock(struct ocfs2_super *osb, | |||
3360 | 3393 | ||
3361 | spin_lock_irqsave(&lockres->l_lock, flags); | 3394 | spin_lock_irqsave(&lockres->l_lock, flags); |
3362 | 3395 | ||
3363 | BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED)); | ||
3364 | |||
3365 | recheck: | 3396 | recheck: |
3397 | /* | ||
3398 | * Is it still blocking? If not, we have no more work to do. | ||
3399 | */ | ||
3400 | if (!(lockres->l_flags & OCFS2_LOCK_BLOCKED)) { | ||
3401 | BUG_ON(lockres->l_blocking != DLM_LOCK_NL); | ||
3402 | spin_unlock_irqrestore(&lockres->l_lock, flags); | ||
3403 | ret = 0; | ||
3404 | goto leave; | ||
3405 | } | ||
3406 | |||
3366 | if (lockres->l_flags & OCFS2_LOCK_BUSY) { | 3407 | if (lockres->l_flags & OCFS2_LOCK_BUSY) { |
3367 | /* XXX | 3408 | /* XXX |
3368 | * This is a *big* race. The OCFS2_LOCK_PENDING flag | 3409 | * This is a *big* race. The OCFS2_LOCK_PENDING flag |
@@ -3401,6 +3442,31 @@ recheck: | |||
3401 | goto leave; | 3442 | goto leave; |
3402 | } | 3443 | } |
3403 | 3444 | ||
3445 | /* | ||
3446 | * This prevents livelocks. OCFS2_LOCK_UPCONVERT_FINISHING flag is | ||
3447 | * set when the ast is received for an upconvert just before the | ||
3448 | * OCFS2_LOCK_BUSY flag is cleared. Now if the fs received a bast | ||
3449 | * on the heels of the ast, we want to delay the downconvert just | ||
3450 | * enough to allow the up requestor to do its task. Because this | ||
3451 | * lock is in the blocked queue, the lock will be downconverted | ||
3452 | * as soon as the requestor is done with the lock. | ||
3453 | */ | ||
3454 | if (lockres->l_flags & OCFS2_LOCK_UPCONVERT_FINISHING) | ||
3455 | goto leave_requeue; | ||
3456 | |||
3457 | /* | ||
3458 | * How can we block and yet be at NL? We were trying to upconvert | ||
3459 | * from NL and got canceled. The code comes back here, and now | ||
3460 | * we notice and clear BLOCKING. | ||
3461 | */ | ||
3462 | if (lockres->l_level == DLM_LOCK_NL) { | ||
3463 | BUG_ON(lockres->l_ex_holders || lockres->l_ro_holders); | ||
3464 | lockres->l_blocking = DLM_LOCK_NL; | ||
3465 | lockres_clear_flags(lockres, OCFS2_LOCK_BLOCKED); | ||
3466 | spin_unlock_irqrestore(&lockres->l_lock, flags); | ||
3467 | goto leave; | ||
3468 | } | ||
3469 | |||
3404 | /* if we're blocking an exclusive and we have *any* holders, | 3470 | /* if we're blocking an exclusive and we have *any* holders, |
3405 | * then requeue. */ | 3471 | * then requeue. */ |
3406 | if ((lockres->l_blocking == DLM_LOCK_EX) | 3472 | if ((lockres->l_blocking == DLM_LOCK_EX) |
@@ -3438,6 +3504,7 @@ recheck: | |||
3438 | * may sleep, so we save off a copy of what we're blocking as | 3504 | * may sleep, so we save off a copy of what we're blocking as |
3439 | * it may change while we're not holding the spin lock. */ | 3505 | * it may change while we're not holding the spin lock. */ |
3440 | blocking = lockres->l_blocking; | 3506 | blocking = lockres->l_blocking; |
3507 | level = lockres->l_level; | ||
3441 | spin_unlock_irqrestore(&lockres->l_lock, flags); | 3508 | spin_unlock_irqrestore(&lockres->l_lock, flags); |
3442 | 3509 | ||
3443 | ctl->unblock_action = lockres->l_ops->downconvert_worker(lockres, blocking); | 3510 | ctl->unblock_action = lockres->l_ops->downconvert_worker(lockres, blocking); |
@@ -3446,7 +3513,7 @@ recheck: | |||
3446 | goto leave; | 3513 | goto leave; |
3447 | 3514 | ||
3448 | spin_lock_irqsave(&lockres->l_lock, flags); | 3515 | spin_lock_irqsave(&lockres->l_lock, flags); |
3449 | if (blocking != lockres->l_blocking) { | 3516 | if ((blocking != lockres->l_blocking) || (level != lockres->l_level)) { |
3450 | /* If this changed underneath us, then we can't drop | 3517 | /* If this changed underneath us, then we can't drop |
3451 | * it just yet. */ | 3518 | * it just yet. */ |
3452 | goto recheck; | 3519 | goto recheck; |
diff --git a/fs/ocfs2/export.c b/fs/ocfs2/export.c index 15713cbb865c..19ad145d2af3 100644 --- a/fs/ocfs2/export.c +++ b/fs/ocfs2/export.c | |||
@@ -239,7 +239,7 @@ static int ocfs2_encode_fh(struct dentry *dentry, u32 *fh_in, int *max_len, | |||
239 | mlog(0, "Encoding parent: blkno: %llu, generation: %u\n", | 239 | mlog(0, "Encoding parent: blkno: %llu, generation: %u\n", |
240 | (unsigned long long)blkno, generation); | 240 | (unsigned long long)blkno, generation); |
241 | } | 241 | } |
242 | 242 | ||
243 | *max_len = len; | 243 | *max_len = len; |
244 | 244 | ||
245 | bail: | 245 | bail: |
diff --git a/fs/ocfs2/extent_map.c b/fs/ocfs2/extent_map.c index d35a27f4523e..5328529e7fd2 100644 --- a/fs/ocfs2/extent_map.c +++ b/fs/ocfs2/extent_map.c | |||
@@ -192,7 +192,7 @@ static int ocfs2_try_to_merge_extent_map(struct ocfs2_extent_map_item *emi, | |||
192 | emi->ei_clusters += ins->ei_clusters; | 192 | emi->ei_clusters += ins->ei_clusters; |
193 | return 1; | 193 | return 1; |
194 | } else if ((ins->ei_phys + ins->ei_clusters) == emi->ei_phys && | 194 | } else if ((ins->ei_phys + ins->ei_clusters) == emi->ei_phys && |
195 | (ins->ei_cpos + ins->ei_clusters) == emi->ei_phys && | 195 | (ins->ei_cpos + ins->ei_clusters) == emi->ei_cpos && |
196 | ins->ei_flags == emi->ei_flags) { | 196 | ins->ei_flags == emi->ei_flags) { |
197 | emi->ei_phys = ins->ei_phys; | 197 | emi->ei_phys = ins->ei_phys; |
198 | emi->ei_cpos = ins->ei_cpos; | 198 | emi->ei_cpos = ins->ei_cpos; |
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c index 06ccf6a86d35..558ce0312421 100644 --- a/fs/ocfs2/file.c +++ b/fs/ocfs2/file.c | |||
@@ -749,7 +749,7 @@ static int ocfs2_write_zero_page(struct inode *inode, | |||
749 | int ret; | 749 | int ret; |
750 | 750 | ||
751 | offset = (size & (PAGE_CACHE_SIZE-1)); /* Within page */ | 751 | offset = (size & (PAGE_CACHE_SIZE-1)); /* Within page */ |
752 | /* ugh. in prepare/commit_write, if from==to==start of block, we | 752 | /* ugh. in prepare/commit_write, if from==to==start of block, we |
753 | ** skip the prepare. make sure we never send an offset for the start | 753 | ** skip the prepare. make sure we never send an offset for the start |
754 | ** of a block | 754 | ** of a block |
755 | */ | 755 | */ |
@@ -1779,7 +1779,7 @@ static int ocfs2_prepare_inode_for_write(struct dentry *dentry, | |||
1779 | struct inode *inode = dentry->d_inode; | 1779 | struct inode *inode = dentry->d_inode; |
1780 | loff_t saved_pos, end; | 1780 | loff_t saved_pos, end; |
1781 | 1781 | ||
1782 | /* | 1782 | /* |
1783 | * We start with a read level meta lock and only jump to an ex | 1783 | * We start with a read level meta lock and only jump to an ex |
1784 | * if we need to make modifications here. | 1784 | * if we need to make modifications here. |
1785 | */ | 1785 | */ |
@@ -2013,8 +2013,8 @@ out_dio: | |||
2013 | /* buffered aio wouldn't have proper lock coverage today */ | 2013 | /* buffered aio wouldn't have proper lock coverage today */ |
2014 | BUG_ON(ret == -EIOCBQUEUED && !(file->f_flags & O_DIRECT)); | 2014 | BUG_ON(ret == -EIOCBQUEUED && !(file->f_flags & O_DIRECT)); |
2015 | 2015 | ||
2016 | if ((file->f_flags & O_DSYNC && !direct_io) || IS_SYNC(inode) || | 2016 | if (((file->f_flags & O_DSYNC) && !direct_io) || IS_SYNC(inode) || |
2017 | (file->f_flags & O_DIRECT && has_refcount)) { | 2017 | ((file->f_flags & O_DIRECT) && has_refcount)) { |
2018 | ret = filemap_fdatawrite_range(file->f_mapping, pos, | 2018 | ret = filemap_fdatawrite_range(file->f_mapping, pos, |
2019 | pos + count - 1); | 2019 | pos + count - 1); |
2020 | if (ret < 0) | 2020 | if (ret < 0) |
@@ -2033,7 +2033,7 @@ out_dio: | |||
2033 | pos + count - 1); | 2033 | pos + count - 1); |
2034 | } | 2034 | } |
2035 | 2035 | ||
2036 | /* | 2036 | /* |
2037 | * deep in g_f_a_w_n()->ocfs2_direct_IO we pass in a ocfs2_dio_end_io | 2037 | * deep in g_f_a_w_n()->ocfs2_direct_IO we pass in a ocfs2_dio_end_io |
2038 | * function pointer which is called when o_direct io completes so that | 2038 | * function pointer which is called when o_direct io completes so that |
2039 | * it can unlock our rw lock. (it's the clustered equivalent of | 2039 | * it can unlock our rw lock. (it's the clustered equivalent of |
@@ -2198,7 +2198,7 @@ static ssize_t ocfs2_file_aio_read(struct kiocb *iocb, | |||
2198 | goto bail; | 2198 | goto bail; |
2199 | } | 2199 | } |
2200 | 2200 | ||
2201 | /* | 2201 | /* |
2202 | * buffered reads protect themselves in ->readpage(). O_DIRECT reads | 2202 | * buffered reads protect themselves in ->readpage(). O_DIRECT reads |
2203 | * need locks to protect pending reads from racing with truncate. | 2203 | * need locks to protect pending reads from racing with truncate. |
2204 | */ | 2204 | */ |
@@ -2220,10 +2220,10 @@ static ssize_t ocfs2_file_aio_read(struct kiocb *iocb, | |||
2220 | * We're fine letting folks race truncates and extending | 2220 | * We're fine letting folks race truncates and extending |
2221 | * writes with read across the cluster, just like they can | 2221 | * writes with read across the cluster, just like they can |
2222 | * locally. Hence no rw_lock during read. | 2222 | * locally. Hence no rw_lock during read. |
2223 | * | 2223 | * |
2224 | * Take and drop the meta data lock to update inode fields | 2224 | * Take and drop the meta data lock to update inode fields |
2225 | * like i_size. This allows the checks down below | 2225 | * like i_size. This allows the checks down below |
2226 | * generic_file_aio_read() a chance of actually working. | 2226 | * generic_file_aio_read() a chance of actually working. |
2227 | */ | 2227 | */ |
2228 | ret = ocfs2_inode_lock_atime(inode, filp->f_vfsmnt, &lock_level); | 2228 | ret = ocfs2_inode_lock_atime(inode, filp->f_vfsmnt, &lock_level); |
2229 | if (ret < 0) { | 2229 | if (ret < 0) { |
@@ -2248,7 +2248,7 @@ static ssize_t ocfs2_file_aio_read(struct kiocb *iocb, | |||
2248 | bail: | 2248 | bail: |
2249 | if (have_alloc_sem) | 2249 | if (have_alloc_sem) |
2250 | up_read(&inode->i_alloc_sem); | 2250 | up_read(&inode->i_alloc_sem); |
2251 | if (rw_level != -1) | 2251 | if (rw_level != -1) |
2252 | ocfs2_rw_unlock(inode, rw_level); | 2252 | ocfs2_rw_unlock(inode, rw_level); |
2253 | mlog_exit(ret); | 2253 | mlog_exit(ret); |
2254 | 2254 | ||
diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c index 0297fb8982b8..88459bdd1ff3 100644 --- a/fs/ocfs2/inode.c +++ b/fs/ocfs2/inode.c | |||
@@ -475,7 +475,7 @@ static int ocfs2_read_locked_inode(struct inode *inode, | |||
475 | if (args->fi_flags & OCFS2_FI_FLAG_ORPHAN_RECOVERY) { | 475 | if (args->fi_flags & OCFS2_FI_FLAG_ORPHAN_RECOVERY) { |
476 | status = ocfs2_try_open_lock(inode, 0); | 476 | status = ocfs2_try_open_lock(inode, 0); |
477 | if (status) { | 477 | if (status) { |
478 | make_bad_inode(inode); | 478 | make_bad_inode(inode); |
479 | return status; | 479 | return status; |
480 | } | 480 | } |
481 | } | 481 | } |
@@ -684,7 +684,7 @@ bail: | |||
684 | return status; | 684 | return status; |
685 | } | 685 | } |
686 | 686 | ||
687 | /* | 687 | /* |
688 | * Serialize with orphan dir recovery. If the process doing | 688 | * Serialize with orphan dir recovery. If the process doing |
689 | * recovery on this orphan dir does an iget() with the dir | 689 | * recovery on this orphan dir does an iget() with the dir |
690 | * i_mutex held, we'll deadlock here. Instead we detect this | 690 | * i_mutex held, we'll deadlock here. Instead we detect this |
diff --git a/fs/ocfs2/ioctl.c b/fs/ocfs2/ioctl.c index 31fbb0619510..7d9d9c132cef 100644 --- a/fs/ocfs2/ioctl.c +++ b/fs/ocfs2/ioctl.c | |||
@@ -7,6 +7,7 @@ | |||
7 | 7 | ||
8 | #include <linux/fs.h> | 8 | #include <linux/fs.h> |
9 | #include <linux/mount.h> | 9 | #include <linux/mount.h> |
10 | #include <linux/compat.h> | ||
10 | 11 | ||
11 | #define MLOG_MASK_PREFIX ML_INODE | 12 | #define MLOG_MASK_PREFIX ML_INODE |
12 | #include <cluster/masklog.h> | 13 | #include <cluster/masklog.h> |
@@ -181,6 +182,10 @@ long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) | |||
181 | #ifdef CONFIG_COMPAT | 182 | #ifdef CONFIG_COMPAT |
182 | long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg) | 183 | long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg) |
183 | { | 184 | { |
185 | bool preserve; | ||
186 | struct reflink_arguments args; | ||
187 | struct inode *inode = file->f_path.dentry->d_inode; | ||
188 | |||
184 | switch (cmd) { | 189 | switch (cmd) { |
185 | case OCFS2_IOC32_GETFLAGS: | 190 | case OCFS2_IOC32_GETFLAGS: |
186 | cmd = OCFS2_IOC_GETFLAGS; | 191 | cmd = OCFS2_IOC_GETFLAGS; |
@@ -195,8 +200,15 @@ long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg) | |||
195 | case OCFS2_IOC_GROUP_EXTEND: | 200 | case OCFS2_IOC_GROUP_EXTEND: |
196 | case OCFS2_IOC_GROUP_ADD: | 201 | case OCFS2_IOC_GROUP_ADD: |
197 | case OCFS2_IOC_GROUP_ADD64: | 202 | case OCFS2_IOC_GROUP_ADD64: |
198 | case OCFS2_IOC_REFLINK: | ||
199 | break; | 203 | break; |
204 | case OCFS2_IOC_REFLINK: | ||
205 | if (copy_from_user(&args, (struct reflink_arguments *)arg, | ||
206 | sizeof(args))) | ||
207 | return -EFAULT; | ||
208 | preserve = (args.preserve != 0); | ||
209 | |||
210 | return ocfs2_reflink_ioctl(inode, compat_ptr(args.old_path), | ||
211 | compat_ptr(args.new_path), preserve); | ||
200 | default: | 212 | default: |
201 | return -ENOIOCTLCMD; | 213 | return -ENOIOCTLCMD; |
202 | } | 214 | } |
diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c index bf34c491ae96..9336c60e3a36 100644 --- a/fs/ocfs2/journal.c +++ b/fs/ocfs2/journal.c | |||
@@ -2034,7 +2034,7 @@ static int ocfs2_queue_orphans(struct ocfs2_super *osb, | |||
2034 | status = -ENOENT; | 2034 | status = -ENOENT; |
2035 | mlog_errno(status); | 2035 | mlog_errno(status); |
2036 | return status; | 2036 | return status; |
2037 | } | 2037 | } |
2038 | 2038 | ||
2039 | mutex_lock(&orphan_dir_inode->i_mutex); | 2039 | mutex_lock(&orphan_dir_inode->i_mutex); |
2040 | status = ocfs2_inode_lock(orphan_dir_inode, NULL, 0); | 2040 | status = ocfs2_inode_lock(orphan_dir_inode, NULL, 0); |
diff --git a/fs/ocfs2/ocfs2.h b/fs/ocfs2/ocfs2.h index 9362eea7424b..740f448041e2 100644 --- a/fs/ocfs2/ocfs2.h +++ b/fs/ocfs2/ocfs2.h | |||
@@ -136,6 +136,10 @@ enum ocfs2_unlock_action { | |||
136 | #define OCFS2_LOCK_PENDING (0x00000400) /* This lockres is pending a | 136 | #define OCFS2_LOCK_PENDING (0x00000400) /* This lockres is pending a |
137 | call to dlm_lock. Only | 137 | call to dlm_lock. Only |
138 | exists with BUSY set. */ | 138 | exists with BUSY set. */ |
139 | #define OCFS2_LOCK_UPCONVERT_FINISHING (0x00000800) /* blocks the dc thread | ||
140 | * from downconverting | ||
141 | * before the upconvert | ||
142 | * has completed */ | ||
139 | 143 | ||
140 | struct ocfs2_lock_res_ops; | 144 | struct ocfs2_lock_res_ops; |
141 | 145 | ||
diff --git a/fs/ocfs2/ocfs2_fs.h b/fs/ocfs2/ocfs2_fs.h index 1a1a679e51b5..7638a38c32bc 100644 --- a/fs/ocfs2/ocfs2_fs.h +++ b/fs/ocfs2/ocfs2_fs.h | |||
@@ -1417,9 +1417,16 @@ static inline int ocfs2_fast_symlink_chars(int blocksize) | |||
1417 | return blocksize - offsetof(struct ocfs2_dinode, id2.i_symlink); | 1417 | return blocksize - offsetof(struct ocfs2_dinode, id2.i_symlink); |
1418 | } | 1418 | } |
1419 | 1419 | ||
1420 | static inline int ocfs2_max_inline_data(int blocksize) | 1420 | static inline int ocfs2_max_inline_data_with_xattr(int blocksize, |
1421 | struct ocfs2_dinode *di) | ||
1421 | { | 1422 | { |
1422 | return blocksize - offsetof(struct ocfs2_dinode, id2.i_data.id_data); | 1423 | if (di && (di->i_dyn_features & OCFS2_INLINE_XATTR_FL)) |
1424 | return blocksize - | ||
1425 | offsetof(struct ocfs2_dinode, id2.i_data.id_data) - | ||
1426 | di->i_xattr_inline_size; | ||
1427 | else | ||
1428 | return blocksize - | ||
1429 | offsetof(struct ocfs2_dinode, id2.i_data.id_data); | ||
1423 | } | 1430 | } |
1424 | 1431 | ||
1425 | static inline int ocfs2_extent_recs_per_inode(int blocksize) | 1432 | static inline int ocfs2_extent_recs_per_inode(int blocksize) |
diff --git a/fs/ocfs2/refcounttree.c b/fs/ocfs2/refcounttree.c index 74db2be75dd6..8ae65c9c020c 100644 --- a/fs/ocfs2/refcounttree.c +++ b/fs/ocfs2/refcounttree.c | |||
@@ -2945,7 +2945,7 @@ static int ocfs2_duplicate_clusters_by_page(handle_t *handle, | |||
2945 | 2945 | ||
2946 | while (offset < end) { | 2946 | while (offset < end) { |
2947 | page_index = offset >> PAGE_CACHE_SHIFT; | 2947 | page_index = offset >> PAGE_CACHE_SHIFT; |
2948 | map_end = (page_index + 1) << PAGE_CACHE_SHIFT; | 2948 | map_end = ((loff_t)page_index + 1) << PAGE_CACHE_SHIFT; |
2949 | if (map_end > end) | 2949 | if (map_end > end) |
2950 | map_end = end; | 2950 | map_end = end; |
2951 | 2951 | ||
@@ -2957,8 +2957,12 @@ static int ocfs2_duplicate_clusters_by_page(handle_t *handle, | |||
2957 | 2957 | ||
2958 | page = grab_cache_page(mapping, page_index); | 2958 | page = grab_cache_page(mapping, page_index); |
2959 | 2959 | ||
2960 | /* This page can't be dirtied before we CoW it out. */ | 2960 | /* |
2961 | BUG_ON(PageDirty(page)); | 2961 | * In case PAGE_CACHE_SIZE <= CLUSTER_SIZE, This page |
2962 | * can't be dirtied before we CoW it out. | ||
2963 | */ | ||
2964 | if (PAGE_CACHE_SIZE <= OCFS2_SB(sb)->s_clustersize) | ||
2965 | BUG_ON(PageDirty(page)); | ||
2962 | 2966 | ||
2963 | if (!PageUptodate(page)) { | 2967 | if (!PageUptodate(page)) { |
2964 | ret = block_read_full_page(page, ocfs2_get_block); | 2968 | ret = block_read_full_page(page, ocfs2_get_block); |
@@ -3170,7 +3174,7 @@ static int ocfs2_cow_sync_writeback(struct super_block *sb, | |||
3170 | 3174 | ||
3171 | while (offset < end) { | 3175 | while (offset < end) { |
3172 | page_index = offset >> PAGE_CACHE_SHIFT; | 3176 | page_index = offset >> PAGE_CACHE_SHIFT; |
3173 | map_end = (page_index + 1) << PAGE_CACHE_SHIFT; | 3177 | map_end = ((loff_t)page_index + 1) << PAGE_CACHE_SHIFT; |
3174 | if (map_end > end) | 3178 | if (map_end > end) |
3175 | map_end = end; | 3179 | map_end = end; |
3176 | 3180 | ||
diff --git a/fs/ocfs2/stack_o2cb.c b/fs/ocfs2/stack_o2cb.c index e49c41050264..3038c92af493 100644 --- a/fs/ocfs2/stack_o2cb.c +++ b/fs/ocfs2/stack_o2cb.c | |||
@@ -277,7 +277,7 @@ static int o2cb_cluster_connect(struct ocfs2_cluster_connection *conn) | |||
277 | u32 dlm_key; | 277 | u32 dlm_key; |
278 | struct dlm_ctxt *dlm; | 278 | struct dlm_ctxt *dlm; |
279 | struct o2dlm_private *priv; | 279 | struct o2dlm_private *priv; |
280 | struct dlm_protocol_version dlm_version; | 280 | struct dlm_protocol_version fs_version; |
281 | 281 | ||
282 | BUG_ON(conn == NULL); | 282 | BUG_ON(conn == NULL); |
283 | BUG_ON(o2cb_stack.sp_proto == NULL); | 283 | BUG_ON(o2cb_stack.sp_proto == NULL); |
@@ -304,18 +304,18 @@ static int o2cb_cluster_connect(struct ocfs2_cluster_connection *conn) | |||
304 | /* used by the dlm code to make message headers unique, each | 304 | /* used by the dlm code to make message headers unique, each |
305 | * node in this domain must agree on this. */ | 305 | * node in this domain must agree on this. */ |
306 | dlm_key = crc32_le(0, conn->cc_name, conn->cc_namelen); | 306 | dlm_key = crc32_le(0, conn->cc_name, conn->cc_namelen); |
307 | dlm_version.pv_major = conn->cc_version.pv_major; | 307 | fs_version.pv_major = conn->cc_version.pv_major; |
308 | dlm_version.pv_minor = conn->cc_version.pv_minor; | 308 | fs_version.pv_minor = conn->cc_version.pv_minor; |
309 | 309 | ||
310 | dlm = dlm_register_domain(conn->cc_name, dlm_key, &dlm_version); | 310 | dlm = dlm_register_domain(conn->cc_name, dlm_key, &fs_version); |
311 | if (IS_ERR(dlm)) { | 311 | if (IS_ERR(dlm)) { |
312 | rc = PTR_ERR(dlm); | 312 | rc = PTR_ERR(dlm); |
313 | mlog_errno(rc); | 313 | mlog_errno(rc); |
314 | goto out_free; | 314 | goto out_free; |
315 | } | 315 | } |
316 | 316 | ||
317 | conn->cc_version.pv_major = dlm_version.pv_major; | 317 | conn->cc_version.pv_major = fs_version.pv_major; |
318 | conn->cc_version.pv_minor = dlm_version.pv_minor; | 318 | conn->cc_version.pv_minor = fs_version.pv_minor; |
319 | conn->cc_lockspace = dlm; | 319 | conn->cc_lockspace = dlm; |
320 | 320 | ||
321 | dlm_register_eviction_cb(dlm, &priv->op_eviction_cb); | 321 | dlm_register_eviction_cb(dlm, &priv->op_eviction_cb); |
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c index 26069917a9f5..755cd49a5ef3 100644 --- a/fs/ocfs2/super.c +++ b/fs/ocfs2/super.c | |||
@@ -1062,7 +1062,7 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent) | |||
1062 | "file system, but write access is " | 1062 | "file system, but write access is " |
1063 | "unavailable.\n"); | 1063 | "unavailable.\n"); |
1064 | else | 1064 | else |
1065 | mlog_errno(status); | 1065 | mlog_errno(status); |
1066 | goto read_super_error; | 1066 | goto read_super_error; |
1067 | } | 1067 | } |
1068 | 1068 | ||
diff --git a/fs/ocfs2/symlink.c b/fs/ocfs2/symlink.c index 49b133ccbf11..32499d213fc4 100644 --- a/fs/ocfs2/symlink.c +++ b/fs/ocfs2/symlink.c | |||
@@ -137,20 +137,20 @@ static void *ocfs2_fast_follow_link(struct dentry *dentry, | |||
137 | } | 137 | } |
138 | 138 | ||
139 | memcpy(link, target, len); | 139 | memcpy(link, target, len); |
140 | nd_set_link(nd, link); | ||
141 | 140 | ||
142 | bail: | 141 | bail: |
142 | nd_set_link(nd, status ? ERR_PTR(status) : link); | ||
143 | brelse(bh); | 143 | brelse(bh); |
144 | 144 | ||
145 | mlog_exit(status); | 145 | mlog_exit(status); |
146 | return status ? ERR_PTR(status) : link; | 146 | return NULL; |
147 | } | 147 | } |
148 | 148 | ||
149 | static void ocfs2_fast_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie) | 149 | static void ocfs2_fast_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie) |
150 | { | 150 | { |
151 | char *link = cookie; | 151 | char *link = nd_get_link(nd); |
152 | 152 | if (!IS_ERR(link)) | |
153 | kfree(link); | 153 | kfree(link); |
154 | } | 154 | } |
155 | 155 | ||
156 | const struct inode_operations ocfs2_symlink_inode_operations = { | 156 | const struct inode_operations ocfs2_symlink_inode_operations = { |
diff --git a/fs/ocfs2/uptodate.c b/fs/ocfs2/uptodate.c index c61369342a27..a0a120e82b97 100644 --- a/fs/ocfs2/uptodate.c +++ b/fs/ocfs2/uptodate.c | |||
@@ -267,8 +267,8 @@ static int ocfs2_buffer_cached(struct ocfs2_caching_info *ci, | |||
267 | } | 267 | } |
268 | 268 | ||
269 | /* Warning: even if it returns true, this does *not* guarantee that | 269 | /* Warning: even if it returns true, this does *not* guarantee that |
270 | * the block is stored in our inode metadata cache. | 270 | * the block is stored in our inode metadata cache. |
271 | * | 271 | * |
272 | * This can be called under lock_buffer() | 272 | * This can be called under lock_buffer() |
273 | */ | 273 | */ |
274 | int ocfs2_buffer_uptodate(struct ocfs2_caching_info *ci, | 274 | int ocfs2_buffer_uptodate(struct ocfs2_caching_info *ci, |
diff --git a/fs/proc/base.c b/fs/proc/base.c index 18d5cc62d8ed..58324c299165 100644 --- a/fs/proc/base.c +++ b/fs/proc/base.c | |||
@@ -1419,7 +1419,6 @@ static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd) | |||
1419 | goto out; | 1419 | goto out; |
1420 | 1420 | ||
1421 | error = PROC_I(inode)->op.proc_get_link(inode, &nd->path); | 1421 | error = PROC_I(inode)->op.proc_get_link(inode, &nd->path); |
1422 | nd->last_type = LAST_BIND; | ||
1423 | out: | 1422 | out: |
1424 | return ERR_PTR(error); | 1423 | return ERR_PTR(error); |
1425 | } | 1424 | } |
@@ -2370,16 +2369,30 @@ static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd) | |||
2370 | { | 2369 | { |
2371 | struct pid_namespace *ns = dentry->d_sb->s_fs_info; | 2370 | struct pid_namespace *ns = dentry->d_sb->s_fs_info; |
2372 | pid_t tgid = task_tgid_nr_ns(current, ns); | 2371 | pid_t tgid = task_tgid_nr_ns(current, ns); |
2373 | char tmp[PROC_NUMBUF]; | 2372 | char *name = ERR_PTR(-ENOENT); |
2374 | if (!tgid) | 2373 | if (tgid) { |
2375 | return ERR_PTR(-ENOENT); | 2374 | name = __getname(); |
2376 | sprintf(tmp, "%d", task_tgid_nr_ns(current, ns)); | 2375 | if (!name) |
2377 | return ERR_PTR(vfs_follow_link(nd,tmp)); | 2376 | name = ERR_PTR(-ENOMEM); |
2377 | else | ||
2378 | sprintf(name, "%d", tgid); | ||
2379 | } | ||
2380 | nd_set_link(nd, name); | ||
2381 | return NULL; | ||
2382 | } | ||
2383 | |||
2384 | static void proc_self_put_link(struct dentry *dentry, struct nameidata *nd, | ||
2385 | void *cookie) | ||
2386 | { | ||
2387 | char *s = nd_get_link(nd); | ||
2388 | if (!IS_ERR(s)) | ||
2389 | __putname(s); | ||
2378 | } | 2390 | } |
2379 | 2391 | ||
2380 | static const struct inode_operations proc_self_inode_operations = { | 2392 | static const struct inode_operations proc_self_inode_operations = { |
2381 | .readlink = proc_self_readlink, | 2393 | .readlink = proc_self_readlink, |
2382 | .follow_link = proc_self_follow_link, | 2394 | .follow_link = proc_self_follow_link, |
2395 | .put_link = proc_self_put_link, | ||
2383 | }; | 2396 | }; |
2384 | 2397 | ||
2385 | /* | 2398 | /* |
diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c index 2efc57173fd7..1739a4aba25f 100644 --- a/fs/ramfs/file-nommu.c +++ b/fs/ramfs/file-nommu.c | |||
@@ -123,30 +123,6 @@ add_error: | |||
123 | 123 | ||
124 | /*****************************************************************************/ | 124 | /*****************************************************************************/ |
125 | /* | 125 | /* |
126 | * check that file shrinkage doesn't leave any VMAs dangling in midair | ||
127 | */ | ||
128 | static int ramfs_nommu_check_mappings(struct inode *inode, | ||
129 | size_t newsize, size_t size) | ||
130 | { | ||
131 | struct vm_area_struct *vma; | ||
132 | struct prio_tree_iter iter; | ||
133 | |||
134 | /* search for VMAs that fall within the dead zone */ | ||
135 | vma_prio_tree_foreach(vma, &iter, &inode->i_mapping->i_mmap, | ||
136 | newsize >> PAGE_SHIFT, | ||
137 | (size + PAGE_SIZE - 1) >> PAGE_SHIFT | ||
138 | ) { | ||
139 | /* found one - only interested if it's shared out of the page | ||
140 | * cache */ | ||
141 | if (vma->vm_flags & VM_SHARED) | ||
142 | return -ETXTBSY; /* not quite true, but near enough */ | ||
143 | } | ||
144 | |||
145 | return 0; | ||
146 | } | ||
147 | |||
148 | /*****************************************************************************/ | ||
149 | /* | ||
150 | * | 126 | * |
151 | */ | 127 | */ |
152 | static int ramfs_nommu_resize(struct inode *inode, loff_t newsize, loff_t size) | 128 | static int ramfs_nommu_resize(struct inode *inode, loff_t newsize, loff_t size) |
@@ -164,7 +140,7 @@ static int ramfs_nommu_resize(struct inode *inode, loff_t newsize, loff_t size) | |||
164 | 140 | ||
165 | /* check that a decrease in size doesn't cut off any shared mappings */ | 141 | /* check that a decrease in size doesn't cut off any shared mappings */ |
166 | if (newsize < size) { | 142 | if (newsize < size) { |
167 | ret = ramfs_nommu_check_mappings(inode, newsize, size); | 143 | ret = nommu_shrink_inode_mappings(inode, size, newsize); |
168 | if (ret < 0) | 144 | if (ret < 0) |
169 | return ret; | 145 | return ret; |
170 | } | 146 | } |
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c index 9087b10209e6..2df0f5c7c60b 100644 --- a/fs/reiserfs/inode.c +++ b/fs/reiserfs/inode.c | |||
@@ -1497,9 +1497,11 @@ struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key) | |||
1497 | 1497 | ||
1498 | args.objectid = key->on_disk_key.k_objectid; | 1498 | args.objectid = key->on_disk_key.k_objectid; |
1499 | args.dirid = key->on_disk_key.k_dir_id; | 1499 | args.dirid = key->on_disk_key.k_dir_id; |
1500 | reiserfs_write_unlock(s); | ||
1500 | inode = iget5_locked(s, key->on_disk_key.k_objectid, | 1501 | inode = iget5_locked(s, key->on_disk_key.k_objectid, |
1501 | reiserfs_find_actor, reiserfs_init_locked_inode, | 1502 | reiserfs_find_actor, reiserfs_init_locked_inode, |
1502 | (void *)(&args)); | 1503 | (void *)(&args)); |
1504 | reiserfs_write_lock(s); | ||
1503 | if (!inode) | 1505 | if (!inode) |
1504 | return ERR_PTR(-ENOMEM); | 1506 | return ERR_PTR(-ENOMEM); |
1505 | 1507 | ||
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c index 83ac4d3b3cb0..ba98546fabbd 100644 --- a/fs/reiserfs/journal.c +++ b/fs/reiserfs/journal.c | |||
@@ -2913,7 +2913,9 @@ int journal_init(struct super_block *sb, const char *j_dev_name, | |||
2913 | journal->j_mount_id = 10; | 2913 | journal->j_mount_id = 10; |
2914 | journal->j_state = 0; | 2914 | journal->j_state = 0; |
2915 | atomic_set(&(journal->j_jlock), 0); | 2915 | atomic_set(&(journal->j_jlock), 0); |
2916 | reiserfs_write_unlock(sb); | ||
2916 | journal->j_cnode_free_list = allocate_cnodes(num_cnodes); | 2917 | journal->j_cnode_free_list = allocate_cnodes(num_cnodes); |
2918 | reiserfs_write_lock(sb); | ||
2917 | journal->j_cnode_free_orig = journal->j_cnode_free_list; | 2919 | journal->j_cnode_free_orig = journal->j_cnode_free_list; |
2918 | journal->j_cnode_free = journal->j_cnode_free_list ? num_cnodes : 0; | 2920 | journal->j_cnode_free = journal->j_cnode_free_list ? num_cnodes : 0; |
2919 | journal->j_cnode_used = 0; | 2921 | journal->j_cnode_used = 0; |
diff --git a/fs/romfs/super.c b/fs/romfs/super.c index c117fa80d1e9..42d213546894 100644 --- a/fs/romfs/super.c +++ b/fs/romfs/super.c | |||
@@ -544,6 +544,7 @@ error: | |||
544 | error_rsb_inval: | 544 | error_rsb_inval: |
545 | ret = -EINVAL; | 545 | ret = -EINVAL; |
546 | error_rsb: | 546 | error_rsb: |
547 | kfree(rsb); | ||
547 | return ret; | 548 | return ret; |
548 | } | 549 | } |
549 | 550 | ||
diff --git a/fs/sysfs/inode.c b/fs/sysfs/inode.c index 220b758523ae..6a06a1d1ea7b 100644 --- a/fs/sysfs/inode.c +++ b/fs/sysfs/inode.c | |||
@@ -81,24 +81,23 @@ int sysfs_sd_setattr(struct sysfs_dirent *sd, struct iattr * iattr) | |||
81 | if (!sd_attrs) | 81 | if (!sd_attrs) |
82 | return -ENOMEM; | 82 | return -ENOMEM; |
83 | sd->s_iattr = sd_attrs; | 83 | sd->s_iattr = sd_attrs; |
84 | } else { | 84 | } |
85 | /* attributes were changed at least once in past */ | 85 | /* attributes were changed at least once in past */ |
86 | iattrs = &sd_attrs->ia_iattr; | 86 | iattrs = &sd_attrs->ia_iattr; |
87 | 87 | ||
88 | if (ia_valid & ATTR_UID) | 88 | if (ia_valid & ATTR_UID) |
89 | iattrs->ia_uid = iattr->ia_uid; | 89 | iattrs->ia_uid = iattr->ia_uid; |
90 | if (ia_valid & ATTR_GID) | 90 | if (ia_valid & ATTR_GID) |
91 | iattrs->ia_gid = iattr->ia_gid; | 91 | iattrs->ia_gid = iattr->ia_gid; |
92 | if (ia_valid & ATTR_ATIME) | 92 | if (ia_valid & ATTR_ATIME) |
93 | iattrs->ia_atime = iattr->ia_atime; | 93 | iattrs->ia_atime = iattr->ia_atime; |
94 | if (ia_valid & ATTR_MTIME) | 94 | if (ia_valid & ATTR_MTIME) |
95 | iattrs->ia_mtime = iattr->ia_mtime; | 95 | iattrs->ia_mtime = iattr->ia_mtime; |
96 | if (ia_valid & ATTR_CTIME) | 96 | if (ia_valid & ATTR_CTIME) |
97 | iattrs->ia_ctime = iattr->ia_ctime; | 97 | iattrs->ia_ctime = iattr->ia_ctime; |
98 | if (ia_valid & ATTR_MODE) { | 98 | if (ia_valid & ATTR_MODE) { |
99 | umode_t mode = iattr->ia_mode; | 99 | umode_t mode = iattr->ia_mode; |
100 | iattrs->ia_mode = sd->s_mode = mode; | 100 | iattrs->ia_mode = sd->s_mode = mode; |
101 | } | ||
102 | } | 101 | } |
103 | return 0; | 102 | return 0; |
104 | } | 103 | } |
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c index 09783cc444ac..77414db10dc2 100644 --- a/fs/xfs/linux-2.6/xfs_super.c +++ b/fs/xfs/linux-2.6/xfs_super.c | |||
@@ -954,16 +954,14 @@ xfs_fs_destroy_inode( | |||
954 | ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIM)); | 954 | ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIM)); |
955 | 955 | ||
956 | /* | 956 | /* |
957 | * If we have nothing to flush with this inode then complete the | 957 | * We always use background reclaim here because even if the |
958 | * teardown now, otherwise delay the flush operation. | 958 | * inode is clean, it still may be under IO and hence we have |
959 | * to take the flush lock. The background reclaim path handles | ||
960 | * this more efficiently than we can here, so simply let background | ||
961 | * reclaim tear down all inodes. | ||
959 | */ | 962 | */ |
960 | if (!xfs_inode_clean(ip)) { | ||
961 | xfs_inode_set_reclaim_tag(ip); | ||
962 | return; | ||
963 | } | ||
964 | |||
965 | out_reclaim: | 963 | out_reclaim: |
966 | xfs_ireclaim(ip); | 964 | xfs_inode_set_reclaim_tag(ip); |
967 | } | 965 | } |
968 | 966 | ||
969 | /* | 967 | /* |
diff --git a/fs/xfs/linux-2.6/xfs_sync.c b/fs/xfs/linux-2.6/xfs_sync.c index 6fed97a8cd3e..1f5e4bb5e970 100644 --- a/fs/xfs/linux-2.6/xfs_sync.c +++ b/fs/xfs/linux-2.6/xfs_sync.c | |||
@@ -65,7 +65,6 @@ xfs_inode_ag_lookup( | |||
65 | * as the tree is sparse and a gang lookup walks to find | 65 | * as the tree is sparse and a gang lookup walks to find |
66 | * the number of objects requested. | 66 | * the number of objects requested. |
67 | */ | 67 | */ |
68 | read_lock(&pag->pag_ici_lock); | ||
69 | if (tag == XFS_ICI_NO_TAG) { | 68 | if (tag == XFS_ICI_NO_TAG) { |
70 | nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, | 69 | nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, |
71 | (void **)&ip, *first_index, 1); | 70 | (void **)&ip, *first_index, 1); |
@@ -74,7 +73,7 @@ xfs_inode_ag_lookup( | |||
74 | (void **)&ip, *first_index, 1, tag); | 73 | (void **)&ip, *first_index, 1, tag); |
75 | } | 74 | } |
76 | if (!nr_found) | 75 | if (!nr_found) |
77 | goto unlock; | 76 | return NULL; |
78 | 77 | ||
79 | /* | 78 | /* |
80 | * Update the index for the next lookup. Catch overflows | 79 | * Update the index for the next lookup. Catch overflows |
@@ -84,13 +83,8 @@ xfs_inode_ag_lookup( | |||
84 | */ | 83 | */ |
85 | *first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1); | 84 | *first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1); |
86 | if (*first_index < XFS_INO_TO_AGINO(mp, ip->i_ino)) | 85 | if (*first_index < XFS_INO_TO_AGINO(mp, ip->i_ino)) |
87 | goto unlock; | 86 | return NULL; |
88 | |||
89 | return ip; | 87 | return ip; |
90 | |||
91 | unlock: | ||
92 | read_unlock(&pag->pag_ici_lock); | ||
93 | return NULL; | ||
94 | } | 88 | } |
95 | 89 | ||
96 | STATIC int | 90 | STATIC int |
@@ -100,7 +94,8 @@ xfs_inode_ag_walk( | |||
100 | int (*execute)(struct xfs_inode *ip, | 94 | int (*execute)(struct xfs_inode *ip, |
101 | struct xfs_perag *pag, int flags), | 95 | struct xfs_perag *pag, int flags), |
102 | int flags, | 96 | int flags, |
103 | int tag) | 97 | int tag, |
98 | int exclusive) | ||
104 | { | 99 | { |
105 | struct xfs_perag *pag = &mp->m_perag[ag]; | 100 | struct xfs_perag *pag = &mp->m_perag[ag]; |
106 | uint32_t first_index; | 101 | uint32_t first_index; |
@@ -114,10 +109,20 @@ restart: | |||
114 | int error = 0; | 109 | int error = 0; |
115 | xfs_inode_t *ip; | 110 | xfs_inode_t *ip; |
116 | 111 | ||
112 | if (exclusive) | ||
113 | write_lock(&pag->pag_ici_lock); | ||
114 | else | ||
115 | read_lock(&pag->pag_ici_lock); | ||
117 | ip = xfs_inode_ag_lookup(mp, pag, &first_index, tag); | 116 | ip = xfs_inode_ag_lookup(mp, pag, &first_index, tag); |
118 | if (!ip) | 117 | if (!ip) { |
118 | if (exclusive) | ||
119 | write_unlock(&pag->pag_ici_lock); | ||
120 | else | ||
121 | read_unlock(&pag->pag_ici_lock); | ||
119 | break; | 122 | break; |
123 | } | ||
120 | 124 | ||
125 | /* execute releases pag->pag_ici_lock */ | ||
121 | error = execute(ip, pag, flags); | 126 | error = execute(ip, pag, flags); |
122 | if (error == EAGAIN) { | 127 | if (error == EAGAIN) { |
123 | skipped++; | 128 | skipped++; |
@@ -125,9 +130,8 @@ restart: | |||
125 | } | 130 | } |
126 | if (error) | 131 | if (error) |
127 | last_error = error; | 132 | last_error = error; |
128 | /* | 133 | |
129 | * bail out if the filesystem is corrupted. | 134 | /* bail out if the filesystem is corrupted. */ |
130 | */ | ||
131 | if (error == EFSCORRUPTED) | 135 | if (error == EFSCORRUPTED) |
132 | break; | 136 | break; |
133 | 137 | ||
@@ -148,7 +152,8 @@ xfs_inode_ag_iterator( | |||
148 | int (*execute)(struct xfs_inode *ip, | 152 | int (*execute)(struct xfs_inode *ip, |
149 | struct xfs_perag *pag, int flags), | 153 | struct xfs_perag *pag, int flags), |
150 | int flags, | 154 | int flags, |
151 | int tag) | 155 | int tag, |
156 | int exclusive) | ||
152 | { | 157 | { |
153 | int error = 0; | 158 | int error = 0; |
154 | int last_error = 0; | 159 | int last_error = 0; |
@@ -157,7 +162,8 @@ xfs_inode_ag_iterator( | |||
157 | for (ag = 0; ag < mp->m_sb.sb_agcount; ag++) { | 162 | for (ag = 0; ag < mp->m_sb.sb_agcount; ag++) { |
158 | if (!mp->m_perag[ag].pag_ici_init) | 163 | if (!mp->m_perag[ag].pag_ici_init) |
159 | continue; | 164 | continue; |
160 | error = xfs_inode_ag_walk(mp, ag, execute, flags, tag); | 165 | error = xfs_inode_ag_walk(mp, ag, execute, flags, tag, |
166 | exclusive); | ||
161 | if (error) { | 167 | if (error) { |
162 | last_error = error; | 168 | last_error = error; |
163 | if (error == EFSCORRUPTED) | 169 | if (error == EFSCORRUPTED) |
@@ -174,30 +180,31 @@ xfs_sync_inode_valid( | |||
174 | struct xfs_perag *pag) | 180 | struct xfs_perag *pag) |
175 | { | 181 | { |
176 | struct inode *inode = VFS_I(ip); | 182 | struct inode *inode = VFS_I(ip); |
183 | int error = EFSCORRUPTED; | ||
177 | 184 | ||
178 | /* nothing to sync during shutdown */ | 185 | /* nothing to sync during shutdown */ |
179 | if (XFS_FORCED_SHUTDOWN(ip->i_mount)) { | 186 | if (XFS_FORCED_SHUTDOWN(ip->i_mount)) |
180 | read_unlock(&pag->pag_ici_lock); | 187 | goto out_unlock; |
181 | return EFSCORRUPTED; | ||
182 | } | ||
183 | 188 | ||
184 | /* | 189 | /* avoid new or reclaimable inodes. Leave for reclaim code to flush */ |
185 | * If we can't get a reference on the inode, it must be in reclaim. | 190 | error = ENOENT; |
186 | * Leave it for the reclaim code to flush. Also avoid inodes that | 191 | if (xfs_iflags_test(ip, XFS_INEW | XFS_IRECLAIMABLE | XFS_IRECLAIM)) |
187 | * haven't been fully initialised. | 192 | goto out_unlock; |
188 | */ | ||
189 | if (!igrab(inode)) { | ||
190 | read_unlock(&pag->pag_ici_lock); | ||
191 | return ENOENT; | ||
192 | } | ||
193 | read_unlock(&pag->pag_ici_lock); | ||
194 | 193 | ||
195 | if (is_bad_inode(inode) || xfs_iflags_test(ip, XFS_INEW)) { | 194 | /* If we can't grab the inode, it must on it's way to reclaim. */ |
195 | if (!igrab(inode)) | ||
196 | goto out_unlock; | ||
197 | |||
198 | if (is_bad_inode(inode)) { | ||
196 | IRELE(ip); | 199 | IRELE(ip); |
197 | return ENOENT; | 200 | goto out_unlock; |
198 | } | 201 | } |
199 | 202 | ||
200 | return 0; | 203 | /* inode is valid */ |
204 | error = 0; | ||
205 | out_unlock: | ||
206 | read_unlock(&pag->pag_ici_lock); | ||
207 | return error; | ||
201 | } | 208 | } |
202 | 209 | ||
203 | STATIC int | 210 | STATIC int |
@@ -282,7 +289,7 @@ xfs_sync_data( | |||
282 | ASSERT((flags & ~(SYNC_TRYLOCK|SYNC_WAIT)) == 0); | 289 | ASSERT((flags & ~(SYNC_TRYLOCK|SYNC_WAIT)) == 0); |
283 | 290 | ||
284 | error = xfs_inode_ag_iterator(mp, xfs_sync_inode_data, flags, | 291 | error = xfs_inode_ag_iterator(mp, xfs_sync_inode_data, flags, |
285 | XFS_ICI_NO_TAG); | 292 | XFS_ICI_NO_TAG, 0); |
286 | if (error) | 293 | if (error) |
287 | return XFS_ERROR(error); | 294 | return XFS_ERROR(error); |
288 | 295 | ||
@@ -304,7 +311,7 @@ xfs_sync_attr( | |||
304 | ASSERT((flags & ~SYNC_WAIT) == 0); | 311 | ASSERT((flags & ~SYNC_WAIT) == 0); |
305 | 312 | ||
306 | return xfs_inode_ag_iterator(mp, xfs_sync_inode_attr, flags, | 313 | return xfs_inode_ag_iterator(mp, xfs_sync_inode_attr, flags, |
307 | XFS_ICI_NO_TAG); | 314 | XFS_ICI_NO_TAG, 0); |
308 | } | 315 | } |
309 | 316 | ||
310 | STATIC int | 317 | STATIC int |
@@ -664,60 +671,6 @@ xfs_syncd_stop( | |||
664 | kthread_stop(mp->m_sync_task); | 671 | kthread_stop(mp->m_sync_task); |
665 | } | 672 | } |
666 | 673 | ||
667 | STATIC int | ||
668 | xfs_reclaim_inode( | ||
669 | xfs_inode_t *ip, | ||
670 | int sync_mode) | ||
671 | { | ||
672 | xfs_perag_t *pag = xfs_get_perag(ip->i_mount, ip->i_ino); | ||
673 | |||
674 | /* The hash lock here protects a thread in xfs_iget_core from | ||
675 | * racing with us on linking the inode back with a vnode. | ||
676 | * Once we have the XFS_IRECLAIM flag set it will not touch | ||
677 | * us. | ||
678 | */ | ||
679 | write_lock(&pag->pag_ici_lock); | ||
680 | spin_lock(&ip->i_flags_lock); | ||
681 | if (__xfs_iflags_test(ip, XFS_IRECLAIM) || | ||
682 | !__xfs_iflags_test(ip, XFS_IRECLAIMABLE)) { | ||
683 | spin_unlock(&ip->i_flags_lock); | ||
684 | write_unlock(&pag->pag_ici_lock); | ||
685 | return -EAGAIN; | ||
686 | } | ||
687 | __xfs_iflags_set(ip, XFS_IRECLAIM); | ||
688 | spin_unlock(&ip->i_flags_lock); | ||
689 | write_unlock(&pag->pag_ici_lock); | ||
690 | xfs_put_perag(ip->i_mount, pag); | ||
691 | |||
692 | /* | ||
693 | * If the inode is still dirty, then flush it out. If the inode | ||
694 | * is not in the AIL, then it will be OK to flush it delwri as | ||
695 | * long as xfs_iflush() does not keep any references to the inode. | ||
696 | * We leave that decision up to xfs_iflush() since it has the | ||
697 | * knowledge of whether it's OK to simply do a delwri flush of | ||
698 | * the inode or whether we need to wait until the inode is | ||
699 | * pulled from the AIL. | ||
700 | * We get the flush lock regardless, though, just to make sure | ||
701 | * we don't free it while it is being flushed. | ||
702 | */ | ||
703 | xfs_ilock(ip, XFS_ILOCK_EXCL); | ||
704 | xfs_iflock(ip); | ||
705 | |||
706 | /* | ||
707 | * In the case of a forced shutdown we rely on xfs_iflush() to | ||
708 | * wait for the inode to be unpinned before returning an error. | ||
709 | */ | ||
710 | if (!is_bad_inode(VFS_I(ip)) && xfs_iflush(ip, sync_mode) == 0) { | ||
711 | /* synchronize with xfs_iflush_done */ | ||
712 | xfs_iflock(ip); | ||
713 | xfs_ifunlock(ip); | ||
714 | } | ||
715 | |||
716 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | ||
717 | xfs_ireclaim(ip); | ||
718 | return 0; | ||
719 | } | ||
720 | |||
721 | void | 674 | void |
722 | __xfs_inode_set_reclaim_tag( | 675 | __xfs_inode_set_reclaim_tag( |
723 | struct xfs_perag *pag, | 676 | struct xfs_perag *pag, |
@@ -760,19 +713,55 @@ __xfs_inode_clear_reclaim_tag( | |||
760 | } | 713 | } |
761 | 714 | ||
762 | STATIC int | 715 | STATIC int |
763 | xfs_reclaim_inode_now( | 716 | xfs_reclaim_inode( |
764 | struct xfs_inode *ip, | 717 | struct xfs_inode *ip, |
765 | struct xfs_perag *pag, | 718 | struct xfs_perag *pag, |
766 | int flags) | 719 | int sync_mode) |
767 | { | 720 | { |
768 | /* ignore if already under reclaim */ | 721 | /* |
769 | if (xfs_iflags_test(ip, XFS_IRECLAIM)) { | 722 | * The radix tree lock here protects a thread in xfs_iget from racing |
770 | read_unlock(&pag->pag_ici_lock); | 723 | * with us starting reclaim on the inode. Once we have the |
724 | * XFS_IRECLAIM flag set it will not touch us. | ||
725 | */ | ||
726 | spin_lock(&ip->i_flags_lock); | ||
727 | ASSERT_ALWAYS(__xfs_iflags_test(ip, XFS_IRECLAIMABLE)); | ||
728 | if (__xfs_iflags_test(ip, XFS_IRECLAIM)) { | ||
729 | /* ignore as it is already under reclaim */ | ||
730 | spin_unlock(&ip->i_flags_lock); | ||
731 | write_unlock(&pag->pag_ici_lock); | ||
771 | return 0; | 732 | return 0; |
772 | } | 733 | } |
773 | read_unlock(&pag->pag_ici_lock); | 734 | __xfs_iflags_set(ip, XFS_IRECLAIM); |
735 | spin_unlock(&ip->i_flags_lock); | ||
736 | write_unlock(&pag->pag_ici_lock); | ||
774 | 737 | ||
775 | return xfs_reclaim_inode(ip, flags); | 738 | /* |
739 | * If the inode is still dirty, then flush it out. If the inode | ||
740 | * is not in the AIL, then it will be OK to flush it delwri as | ||
741 | * long as xfs_iflush() does not keep any references to the inode. | ||
742 | * We leave that decision up to xfs_iflush() since it has the | ||
743 | * knowledge of whether it's OK to simply do a delwri flush of | ||
744 | * the inode or whether we need to wait until the inode is | ||
745 | * pulled from the AIL. | ||
746 | * We get the flush lock regardless, though, just to make sure | ||
747 | * we don't free it while it is being flushed. | ||
748 | */ | ||
749 | xfs_ilock(ip, XFS_ILOCK_EXCL); | ||
750 | xfs_iflock(ip); | ||
751 | |||
752 | /* | ||
753 | * In the case of a forced shutdown we rely on xfs_iflush() to | ||
754 | * wait for the inode to be unpinned before returning an error. | ||
755 | */ | ||
756 | if (!is_bad_inode(VFS_I(ip)) && xfs_iflush(ip, sync_mode) == 0) { | ||
757 | /* synchronize with xfs_iflush_done */ | ||
758 | xfs_iflock(ip); | ||
759 | xfs_ifunlock(ip); | ||
760 | } | ||
761 | |||
762 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | ||
763 | xfs_ireclaim(ip); | ||
764 | return 0; | ||
776 | } | 765 | } |
777 | 766 | ||
778 | int | 767 | int |
@@ -780,6 +769,6 @@ xfs_reclaim_inodes( | |||
780 | xfs_mount_t *mp, | 769 | xfs_mount_t *mp, |
781 | int mode) | 770 | int mode) |
782 | { | 771 | { |
783 | return xfs_inode_ag_iterator(mp, xfs_reclaim_inode_now, mode, | 772 | return xfs_inode_ag_iterator(mp, xfs_reclaim_inode, mode, |
784 | XFS_ICI_RECLAIM_TAG); | 773 | XFS_ICI_RECLAIM_TAG, 1); |
785 | } | 774 | } |
diff --git a/fs/xfs/linux-2.6/xfs_sync.h b/fs/xfs/linux-2.6/xfs_sync.h index a500b4d91835..ea932b43335d 100644 --- a/fs/xfs/linux-2.6/xfs_sync.h +++ b/fs/xfs/linux-2.6/xfs_sync.h | |||
@@ -54,6 +54,6 @@ void __xfs_inode_clear_reclaim_tag(struct xfs_mount *mp, struct xfs_perag *pag, | |||
54 | int xfs_sync_inode_valid(struct xfs_inode *ip, struct xfs_perag *pag); | 54 | int xfs_sync_inode_valid(struct xfs_inode *ip, struct xfs_perag *pag); |
55 | int xfs_inode_ag_iterator(struct xfs_mount *mp, | 55 | int xfs_inode_ag_iterator(struct xfs_mount *mp, |
56 | int (*execute)(struct xfs_inode *ip, struct xfs_perag *pag, int flags), | 56 | int (*execute)(struct xfs_inode *ip, struct xfs_perag *pag, int flags), |
57 | int flags, int tag); | 57 | int flags, int tag, int write_lock); |
58 | 58 | ||
59 | #endif | 59 | #endif |
diff --git a/fs/xfs/quota/xfs_qm_syscalls.c b/fs/xfs/quota/xfs_qm_syscalls.c index 71af76fe8a23..873e07e29074 100644 --- a/fs/xfs/quota/xfs_qm_syscalls.c +++ b/fs/xfs/quota/xfs_qm_syscalls.c | |||
@@ -891,7 +891,7 @@ xfs_qm_dqrele_all_inodes( | |||
891 | uint flags) | 891 | uint flags) |
892 | { | 892 | { |
893 | ASSERT(mp->m_quotainfo); | 893 | ASSERT(mp->m_quotainfo); |
894 | xfs_inode_ag_iterator(mp, xfs_dqrele_inode, flags, XFS_ICI_NO_TAG); | 894 | xfs_inode_ag_iterator(mp, xfs_dqrele_inode, flags, XFS_ICI_NO_TAG, 0); |
895 | } | 895 | } |
896 | 896 | ||
897 | /*------------------------------------------------------------------------*/ | 897 | /*------------------------------------------------------------------------*/ |
diff --git a/fs/xfs/xfs_dfrag.c b/fs/xfs/xfs_dfrag.c index d1483a4f71b8..84ca1cf16a1e 100644 --- a/fs/xfs/xfs_dfrag.c +++ b/fs/xfs/xfs_dfrag.c | |||
@@ -114,10 +114,82 @@ xfs_swapext( | |||
114 | return error; | 114 | return error; |
115 | } | 115 | } |
116 | 116 | ||
117 | /* | ||
118 | * We need to check that the format of the data fork in the temporary inode is | ||
119 | * valid for the target inode before doing the swap. This is not a problem with | ||
120 | * attr1 because of the fixed fork offset, but attr2 has a dynamically sized | ||
121 | * data fork depending on the space the attribute fork is taking so we can get | ||
122 | * invalid formats on the target inode. | ||
123 | * | ||
124 | * E.g. target has space for 7 extents in extent format, temp inode only has | ||
125 | * space for 6. If we defragment down to 7 extents, then the tmp format is a | ||
126 | * btree, but when swapped it needs to be in extent format. Hence we can't just | ||
127 | * blindly swap data forks on attr2 filesystems. | ||
128 | * | ||
129 | * Note that we check the swap in both directions so that we don't end up with | ||
130 | * a corrupt temporary inode, either. | ||
131 | * | ||
132 | * Note that fixing the way xfs_fsr sets up the attribute fork in the source | ||
133 | * inode will prevent this situation from occurring, so all we do here is | ||
134 | * reject and log the attempt. basically we are putting the responsibility on | ||
135 | * userspace to get this right. | ||
136 | */ | ||
137 | static int | ||
138 | xfs_swap_extents_check_format( | ||
139 | xfs_inode_t *ip, /* target inode */ | ||
140 | xfs_inode_t *tip) /* tmp inode */ | ||
141 | { | ||
142 | |||
143 | /* Should never get a local format */ | ||
144 | if (ip->i_d.di_format == XFS_DINODE_FMT_LOCAL || | ||
145 | tip->i_d.di_format == XFS_DINODE_FMT_LOCAL) | ||
146 | return EINVAL; | ||
147 | |||
148 | /* | ||
149 | * if the target inode has less extents that then temporary inode then | ||
150 | * why did userspace call us? | ||
151 | */ | ||
152 | if (ip->i_d.di_nextents < tip->i_d.di_nextents) | ||
153 | return EINVAL; | ||
154 | |||
155 | /* | ||
156 | * if the target inode is in extent form and the temp inode is in btree | ||
157 | * form then we will end up with the target inode in the wrong format | ||
158 | * as we already know there are less extents in the temp inode. | ||
159 | */ | ||
160 | if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS && | ||
161 | tip->i_d.di_format == XFS_DINODE_FMT_BTREE) | ||
162 | return EINVAL; | ||
163 | |||
164 | /* Check temp in extent form to max in target */ | ||
165 | if (tip->i_d.di_format == XFS_DINODE_FMT_EXTENTS && | ||
166 | XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) > ip->i_df.if_ext_max) | ||
167 | return EINVAL; | ||
168 | |||
169 | /* Check target in extent form to max in temp */ | ||
170 | if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS && | ||
171 | XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) > tip->i_df.if_ext_max) | ||
172 | return EINVAL; | ||
173 | |||
174 | /* Check root block of temp in btree form to max in target */ | ||
175 | if (tip->i_d.di_format == XFS_DINODE_FMT_BTREE && | ||
176 | XFS_IFORK_BOFF(ip) && | ||
177 | tip->i_df.if_broot_bytes > XFS_IFORK_BOFF(ip)) | ||
178 | return EINVAL; | ||
179 | |||
180 | /* Check root block of target in btree form to max in temp */ | ||
181 | if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE && | ||
182 | XFS_IFORK_BOFF(tip) && | ||
183 | ip->i_df.if_broot_bytes > XFS_IFORK_BOFF(tip)) | ||
184 | return EINVAL; | ||
185 | |||
186 | return 0; | ||
187 | } | ||
188 | |||
117 | int | 189 | int |
118 | xfs_swap_extents( | 190 | xfs_swap_extents( |
119 | xfs_inode_t *ip, | 191 | xfs_inode_t *ip, /* target inode */ |
120 | xfs_inode_t *tip, | 192 | xfs_inode_t *tip, /* tmp inode */ |
121 | xfs_swapext_t *sxp) | 193 | xfs_swapext_t *sxp) |
122 | { | 194 | { |
123 | xfs_mount_t *mp; | 195 | xfs_mount_t *mp; |
@@ -161,13 +233,6 @@ xfs_swap_extents( | |||
161 | goto out_unlock; | 233 | goto out_unlock; |
162 | } | 234 | } |
163 | 235 | ||
164 | /* Should never get a local format */ | ||
165 | if (ip->i_d.di_format == XFS_DINODE_FMT_LOCAL || | ||
166 | tip->i_d.di_format == XFS_DINODE_FMT_LOCAL) { | ||
167 | error = XFS_ERROR(EINVAL); | ||
168 | goto out_unlock; | ||
169 | } | ||
170 | |||
171 | if (VN_CACHED(VFS_I(tip)) != 0) { | 236 | if (VN_CACHED(VFS_I(tip)) != 0) { |
172 | error = xfs_flushinval_pages(tip, 0, -1, | 237 | error = xfs_flushinval_pages(tip, 0, -1, |
173 | FI_REMAPF_LOCKED); | 238 | FI_REMAPF_LOCKED); |
@@ -189,13 +254,12 @@ xfs_swap_extents( | |||
189 | goto out_unlock; | 254 | goto out_unlock; |
190 | } | 255 | } |
191 | 256 | ||
192 | /* | 257 | /* check inode formats now that data is flushed */ |
193 | * If the target has extended attributes, the tmp file | 258 | error = xfs_swap_extents_check_format(ip, tip); |
194 | * must also in order to ensure the correct data fork | 259 | if (error) { |
195 | * format. | 260 | xfs_fs_cmn_err(CE_NOTE, mp, |
196 | */ | 261 | "%s: inode 0x%llx format is incompatible for exchanging.", |
197 | if ( XFS_IFORK_Q(ip) != XFS_IFORK_Q(tip) ) { | 262 | __FILE__, ip->i_ino); |
198 | error = XFS_ERROR(EINVAL); | ||
199 | goto out_unlock; | 263 | goto out_unlock; |
200 | } | 264 | } |
201 | 265 | ||
@@ -276,6 +340,16 @@ xfs_swap_extents( | |||
276 | *tifp = *tempifp; /* struct copy */ | 340 | *tifp = *tempifp; /* struct copy */ |
277 | 341 | ||
278 | /* | 342 | /* |
343 | * Fix the in-memory data fork values that are dependent on the fork | ||
344 | * offset in the inode. We can't assume they remain the same as attr2 | ||
345 | * has dynamic fork offsets. | ||
346 | */ | ||
347 | ifp->if_ext_max = XFS_IFORK_SIZE(ip, XFS_DATA_FORK) / | ||
348 | (uint)sizeof(xfs_bmbt_rec_t); | ||
349 | tifp->if_ext_max = XFS_IFORK_SIZE(tip, XFS_DATA_FORK) / | ||
350 | (uint)sizeof(xfs_bmbt_rec_t); | ||
351 | |||
352 | /* | ||
279 | * Fix the on-disk inode values | 353 | * Fix the on-disk inode values |
280 | */ | 354 | */ |
281 | tmp = (__uint64_t)ip->i_d.di_nblocks; | 355 | tmp = (__uint64_t)ip->i_d.di_nblocks; |
diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c index fa402a6bbbcf..155e798f30a1 100644 --- a/fs/xfs/xfs_iget.c +++ b/fs/xfs/xfs_iget.c | |||
@@ -73,7 +73,6 @@ xfs_inode_alloc( | |||
73 | ASSERT(atomic_read(&ip->i_pincount) == 0); | 73 | ASSERT(atomic_read(&ip->i_pincount) == 0); |
74 | ASSERT(!spin_is_locked(&ip->i_flags_lock)); | 74 | ASSERT(!spin_is_locked(&ip->i_flags_lock)); |
75 | ASSERT(completion_done(&ip->i_flush)); | 75 | ASSERT(completion_done(&ip->i_flush)); |
76 | ASSERT(!rwsem_is_locked(&ip->i_iolock.mr_lock)); | ||
77 | 76 | ||
78 | mrlock_init(&ip->i_iolock, MRLOCK_BARRIER, "xfsio", ip->i_ino); | 77 | mrlock_init(&ip->i_iolock, MRLOCK_BARRIER, "xfsio", ip->i_ino); |
79 | 78 | ||
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c index 391d36b0e68c..ef77fd88c8e3 100644 --- a/fs/xfs/xfs_inode.c +++ b/fs/xfs/xfs_inode.c | |||
@@ -2842,13 +2842,9 @@ xfs_iflush( | |||
2842 | 2842 | ||
2843 | /* | 2843 | /* |
2844 | * If the inode isn't dirty, then just release the inode flush lock and | 2844 | * If the inode isn't dirty, then just release the inode flush lock and |
2845 | * do nothing. Treat stale inodes the same; we cannot rely on the | 2845 | * do nothing. |
2846 | * backing buffer remaining stale in cache for the remaining life of | ||
2847 | * the stale inode and so xfs_itobp() below may give us a buffer that | ||
2848 | * no longer contains inodes below. Doing this stale check here also | ||
2849 | * avoids forcing the log on pinned, stale inodes. | ||
2850 | */ | 2846 | */ |
2851 | if (xfs_inode_clean(ip) || xfs_iflags_test(ip, XFS_ISTALE)) { | 2847 | if (xfs_inode_clean(ip)) { |
2852 | xfs_ifunlock(ip); | 2848 | xfs_ifunlock(ip); |
2853 | return 0; | 2849 | return 0; |
2854 | } | 2850 | } |
@@ -2872,6 +2868,19 @@ xfs_iflush( | |||
2872 | xfs_iunpin_wait(ip); | 2868 | xfs_iunpin_wait(ip); |
2873 | 2869 | ||
2874 | /* | 2870 | /* |
2871 | * For stale inodes we cannot rely on the backing buffer remaining | ||
2872 | * stale in cache for the remaining life of the stale inode and so | ||
2873 | * xfs_itobp() below may give us a buffer that no longer contains | ||
2874 | * inodes below. We have to check this after ensuring the inode is | ||
2875 | * unpinned so that it is safe to reclaim the stale inode after the | ||
2876 | * flush call. | ||
2877 | */ | ||
2878 | if (xfs_iflags_test(ip, XFS_ISTALE)) { | ||
2879 | xfs_ifunlock(ip); | ||
2880 | return 0; | ||
2881 | } | ||
2882 | |||
2883 | /* | ||
2875 | * This may have been unpinned because the filesystem is shutting | 2884 | * This may have been unpinned because the filesystem is shutting |
2876 | * down forcibly. If that's the case we must not write this inode | 2885 | * down forcibly. If that's the case we must not write this inode |
2877 | * to disk, because the log record didn't make it to disk! | 2886 | * to disk, because the log record didn't make it to disk! |
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c index 9e15a1185362..6be05f756d59 100644 --- a/fs/xfs/xfs_rtalloc.c +++ b/fs/xfs/xfs_rtalloc.c | |||
@@ -1517,6 +1517,8 @@ xfs_rtfree_range( | |||
1517 | */ | 1517 | */ |
1518 | error = xfs_rtfind_forw(mp, tp, end, mp->m_sb.sb_rextents - 1, | 1518 | error = xfs_rtfind_forw(mp, tp, end, mp->m_sb.sb_rextents - 1, |
1519 | &postblock); | 1519 | &postblock); |
1520 | if (error) | ||
1521 | return error; | ||
1520 | /* | 1522 | /* |
1521 | * If there are blocks not being freed at the front of the | 1523 | * If there are blocks not being freed at the front of the |
1522 | * old extent, add summary data for them to be allocated. | 1524 | * old extent, add summary data for them to be allocated. |