tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'afs-20170316' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs

Pull AFS fixes from David Howells:
"Fixes to the AFS filesystem in the kernel.

They fix a variety of bugs. These include some issues fixed for
consistency with other AFS implementations:

- handle AFS mode bits better

- use the client mtime rather than the server mtime in the protocol

- handle the server returning more or less data than was requested in
a FetchData call

- distinguish mountpoints from symlinks based on the mode bits rather
than preemptively reading every symlink to find out what it
actually represents

One other notable change for the user is that files are now flushed on
close analogously with other network filesystems"

* tag 'afs-20170316' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs: (28 commits)
afs: Don't wait for page writeback with the page lock held
afs: ->writepage() shouldn't call clear_page_dirty_for_io()
afs: Fix abort on signal while waiting for call completion
afs: Fix an off-by-one error in afs_send_pages()
afs: Fix afs_kill_pages()
afs: Fix page leak in afs_write_begin()
afs: Don't set PG_error on local EINTR or ENOMEM when filling a page
afs: Populate and use client modification time
afs: Better abort and net error handling
afs: Invalid op ID should abort with RXGEN_OPCODE
afs: Fix the maths in afs_fs_store_data()
afs: Use a bvec rather than a kvec in afs_send_pages()
afs: Make struct afs_read::remain 64-bit
afs: Fix AFS read bug
afs: Prevent callback expiry timer overflow
afs: Migrate vlocation fields to 64-bit
afs: security: Replace rcu_assign_pointer() with RCU_INIT_POINTER()
afs: inode: Replace rcu_assign_pointer() with RCU_INIT_POINTER()
afs: Distinguish mountpoints from symlinks by file mode alone
afs: Flush outstanding writes when an fd is closed
...

Linus Torvalds 57fd0b77 c79d5ff0

+268 -221
+4 -3
fs/afs/callback.c
··· 362 362 { 363 363 struct afs_server *server; 364 364 struct afs_vnode *vnode, *xvnode; 365 - time_t now; 365 + time64_t now; 366 366 long timeout; 367 367 int ret; 368 368 ··· 370 370 371 371 _enter(""); 372 372 373 - now = get_seconds(); 373 + now = ktime_get_real_seconds(); 374 374 375 375 /* find the first vnode to update */ 376 376 spin_lock(&server->cb_lock); ··· 424 424 425 425 /* and then reschedule */ 426 426 _debug("reschedule"); 427 - vnode->update_at = get_seconds() + afs_vnode_update_timeout; 427 + vnode->update_at = ktime_get_real_seconds() + 428 + afs_vnode_update_timeout; 428 429 429 430 spin_lock(&server->cb_lock); 430 431
+5 -6
fs/afs/cmservice.c
··· 187 187 struct afs_callback *cb; 188 188 struct afs_server *server; 189 189 __be32 *bp; 190 - u32 tmp; 191 190 int ret, loop; 192 191 193 192 _enter("{%u}", call->unmarshall); ··· 248 249 if (ret < 0) 249 250 return ret; 250 251 251 - tmp = ntohl(call->tmp); 252 - _debug("CB count: %u", tmp); 253 - if (tmp != call->count && tmp != 0) 252 + call->count2 = ntohl(call->tmp); 253 + _debug("CB count: %u", call->count2); 254 + if (call->count2 != call->count && call->count2 != 0) 254 255 return -EBADMSG; 255 256 call->offset = 0; 256 257 call->unmarshall++; ··· 258 259 case 4: 259 260 _debug("extract CB array"); 260 261 ret = afs_extract_data(call, call->buffer, 261 - call->count * 3 * 4, false); 262 + call->count2 * 3 * 4, false); 262 263 if (ret < 0) 263 264 return ret; 264 265 265 266 _debug("unmarshall CB array"); 266 267 cb = call->request; 267 268 bp = call->buffer; 268 - for (loop = call->count; loop > 0; loop--, cb++) { 269 + for (loop = call->count2; loop > 0; loop--, cb++) { 269 270 cb->version = ntohl(*bp++); 270 271 cb->expiry = ntohl(*bp++); 271 272 cb->type = ntohl(*bp++);
+16 -4
fs/afs/file.c
··· 30 30 31 31 const struct file_operations afs_file_operations = { 32 32 .open = afs_open, 33 + .flush = afs_flush, 33 34 .release = afs_release, 34 35 .llseek = generic_file_llseek, 35 36 .read_iter = generic_file_read_iter, ··· 185 184 if (!req) 186 185 goto enomem; 187 186 187 + /* We request a full page. If the page is a partial one at the 188 + * end of the file, the server will return a short read and the 189 + * unmarshalling code will clear the unfilled space. 190 + */ 188 191 atomic_set(&req->usage, 1); 189 192 req->pos = (loff_t)page->index << PAGE_SHIFT; 190 - req->len = min_t(size_t, i_size_read(inode) - req->pos, 191 - PAGE_SIZE); 193 + req->len = PAGE_SIZE; 192 194 req->nr_pages = 1; 193 195 req->pages[0] = page; 194 196 get_page(page); ··· 212 208 fscache_uncache_page(vnode->cache, page); 213 209 #endif 214 210 BUG_ON(PageFsCache(page)); 215 - goto error; 211 + 212 + if (ret == -EINTR || 213 + ret == -ENOMEM || 214 + ret == -ERESTARTSYS || 215 + ret == -EAGAIN) 216 + goto error; 217 + goto io_error; 216 218 } 217 219 218 220 SetPageUptodate(page); ··· 237 227 _leave(" = 0"); 238 228 return 0; 239 229 230 + io_error: 231 + SetPageError(page); 232 + goto error; 240 233 enomem: 241 234 ret = -ENOMEM; 242 235 error: 243 - SetPageError(page); 244 236 unlock_page(page); 245 237 _leave(" = %d", ret); 246 238 return ret;
+50 -27
fs/afs/fsclient.c
··· 17 17 #include "afs_fs.h" 18 18 19 19 /* 20 + * We need somewhere to discard into in case the server helpfully returns more 21 + * than we asked for in FS.FetchData{,64}. 22 + */ 23 + static u8 afs_discard_buffer[64]; 24 + 25 + /* 20 26 * decode an AFSFid block 21 27 */ 22 28 static void xdr_decode_AFSFid(const __be32 **_bp, struct afs_fid *fid) ··· 111 105 vnode->vfs_inode.i_mode = mode; 112 106 } 113 107 114 - vnode->vfs_inode.i_ctime.tv_sec = status->mtime_server; 108 + vnode->vfs_inode.i_ctime.tv_sec = status->mtime_client; 115 109 vnode->vfs_inode.i_mtime = vnode->vfs_inode.i_ctime; 116 110 vnode->vfs_inode.i_atime = vnode->vfs_inode.i_ctime; 117 111 vnode->vfs_inode.i_version = data_version; ··· 145 139 vnode->cb_version = ntohl(*bp++); 146 140 vnode->cb_expiry = ntohl(*bp++); 147 141 vnode->cb_type = ntohl(*bp++); 148 - vnode->cb_expires = vnode->cb_expiry + get_seconds(); 142 + vnode->cb_expires = vnode->cb_expiry + ktime_get_real_seconds(); 149 143 *_bp = bp; 150 144 } 151 145 ··· 321 315 void *buffer; 322 316 int ret; 323 317 324 - _enter("{%u,%zu/%u;%u/%llu}", 318 + _enter("{%u,%zu/%u;%llu/%llu}", 325 319 call->unmarshall, call->offset, call->count, 326 320 req->remain, req->actual_len); 327 321 ··· 359 353 360 354 req->actual_len |= ntohl(call->tmp); 361 355 _debug("DATA length: %llu", req->actual_len); 362 - /* Check that the server didn't want to send us extra. We 363 - * might want to just discard instead, but that requires 364 - * cooperation from AF_RXRPC. 365 - */ 366 - if (req->actual_len > req->len) 367 - return -EBADMSG; 368 356 369 357 req->remain = req->actual_len; 370 358 call->offset = req->pos & (PAGE_SIZE - 1); ··· 368 368 call->unmarshall++; 369 369 370 370 begin_page: 371 + ASSERTCMP(req->index, <, req->nr_pages); 371 372 if (req->remain > PAGE_SIZE - call->offset) 372 373 size = PAGE_SIZE - call->offset; 373 374 else ··· 379 378 380 379 /* extract the returned data */ 381 380 case 3: 382 - _debug("extract data %u/%llu %zu/%u", 381 + _debug("extract data %llu/%llu %zu/%u", 383 382 req->remain, req->actual_len, call->offset, call->count); 384 383 385 384 buffer = kmap(req->pages[req->index]); ··· 390 389 if (call->offset == PAGE_SIZE) { 391 390 if (req->page_done) 392 391 req->page_done(call, req); 392 + req->index++; 393 393 if (req->remain > 0) { 394 - req->index++; 395 394 call->offset = 0; 395 + if (req->index >= req->nr_pages) { 396 + call->unmarshall = 4; 397 + goto begin_discard; 398 + } 396 399 goto begin_page; 397 400 } 398 401 } 402 + goto no_more_data; 403 + 404 + /* Discard any excess data the server gave us */ 405 + begin_discard: 406 + case 4: 407 + size = min_t(loff_t, sizeof(afs_discard_buffer), req->remain); 408 + call->count = size; 409 + _debug("extract discard %llu/%llu %zu/%u", 410 + req->remain, req->actual_len, call->offset, call->count); 411 + 412 + call->offset = 0; 413 + ret = afs_extract_data(call, afs_discard_buffer, call->count, true); 414 + req->remain -= call->offset; 415 + if (ret < 0) 416 + return ret; 417 + if (req->remain > 0) 418 + goto begin_discard; 399 419 400 420 no_more_data: 401 421 call->offset = 0; 402 - call->unmarshall++; 422 + call->unmarshall = 5; 403 423 404 424 /* extract the metadata */ 405 - case 4: 425 + case 5: 406 426 ret = afs_extract_data(call, call->buffer, 407 427 (21 + 3 + 6) * 4, false); 408 428 if (ret < 0) ··· 438 416 call->offset = 0; 439 417 call->unmarshall++; 440 418 441 - case 5: 419 + case 6: 442 420 break; 443 421 } 444 422 445 - if (call->count < PAGE_SIZE) { 446 - buffer = kmap(req->pages[req->index]); 447 - memset(buffer + call->count, 0, PAGE_SIZE - call->count); 448 - kunmap(req->pages[req->index]); 423 + for (; req->index < req->nr_pages; req->index++) { 424 + if (call->count < PAGE_SIZE) 425 + zero_user_segment(req->pages[req->index], 426 + call->count, PAGE_SIZE); 449 427 if (req->page_done) 450 428 req->page_done(call, req); 429 + call->count = 0; 451 430 } 452 431 453 432 _leave(" = 0 [done]"); ··· 734 711 memset(bp, 0, padsz); 735 712 bp = (void *) bp + padsz; 736 713 } 737 - *bp++ = htonl(AFS_SET_MODE); 738 - *bp++ = 0; /* mtime */ 714 + *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME); 715 + *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */ 739 716 *bp++ = 0; /* owner */ 740 717 *bp++ = 0; /* group */ 741 718 *bp++ = htonl(mode & S_IALLUGO); /* unix mode */ ··· 1003 980 memset(bp, 0, c_padsz); 1004 981 bp = (void *) bp + c_padsz; 1005 982 } 1006 - *bp++ = htonl(AFS_SET_MODE); 1007 - *bp++ = 0; /* mtime */ 983 + *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME); 984 + *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */ 1008 985 *bp++ = 0; /* owner */ 1009 986 *bp++ = 0; /* group */ 1010 987 *bp++ = htonl(S_IRWXUGO); /* unix mode */ ··· 1203 1180 *bp++ = htonl(vnode->fid.vnode); 1204 1181 *bp++ = htonl(vnode->fid.unique); 1205 1182 1206 - *bp++ = 0; /* mask */ 1207 - *bp++ = 0; /* mtime */ 1183 + *bp++ = htonl(AFS_SET_MTIME); /* mask */ 1184 + *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */ 1208 1185 *bp++ = 0; /* owner */ 1209 1186 *bp++ = 0; /* group */ 1210 1187 *bp++ = 0; /* unix mode */ ··· 1236 1213 _enter(",%x,{%x:%u},,", 1237 1214 key_serial(wb->key), vnode->fid.vid, vnode->fid.vnode); 1238 1215 1239 - size = to - offset; 1216 + size = (loff_t)to - (loff_t)offset; 1240 1217 if (first != last) 1241 1218 size += (loff_t)(last - first) << PAGE_SHIFT; 1242 1219 pos = (loff_t)first << PAGE_SHIFT; ··· 1280 1257 *bp++ = htonl(vnode->fid.vnode); 1281 1258 *bp++ = htonl(vnode->fid.unique); 1282 1259 1283 - *bp++ = 0; /* mask */ 1284 - *bp++ = 0; /* mtime */ 1260 + *bp++ = htonl(AFS_SET_MTIME); /* mask */ 1261 + *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */ 1285 1262 *bp++ = 0; /* owner */ 1286 1263 *bp++ = 0; /* group */ 1287 1264 *bp++ = 0; /* unix mode */
+22 -20
fs/afs/inode.c
··· 54 54 inode->i_fop = &afs_dir_file_operations; 55 55 break; 56 56 case AFS_FTYPE_SYMLINK: 57 - inode->i_mode = S_IFLNK | vnode->status.mode; 58 - inode->i_op = &page_symlink_inode_operations; 57 + /* Symlinks with a mode of 0644 are actually mountpoints. */ 58 + if ((vnode->status.mode & 0777) == 0644) { 59 + inode->i_flags |= S_AUTOMOUNT; 60 + 61 + spin_lock(&vnode->lock); 62 + set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags); 63 + spin_unlock(&vnode->lock); 64 + 65 + inode->i_mode = S_IFDIR | 0555; 66 + inode->i_op = &afs_mntpt_inode_operations; 67 + inode->i_fop = &afs_mntpt_file_operations; 68 + } else { 69 + inode->i_mode = S_IFLNK | vnode->status.mode; 70 + inode->i_op = &page_symlink_inode_operations; 71 + } 59 72 inode_nohighmem(inode); 60 73 break; 61 74 default: ··· 83 70 84 71 set_nlink(inode, vnode->status.nlink); 85 72 inode->i_uid = vnode->status.owner; 86 - inode->i_gid = GLOBAL_ROOT_GID; 73 + inode->i_gid = vnode->status.group; 87 74 inode->i_size = vnode->status.size; 88 - inode->i_ctime.tv_sec = vnode->status.mtime_server; 75 + inode->i_ctime.tv_sec = vnode->status.mtime_client; 89 76 inode->i_ctime.tv_nsec = 0; 90 77 inode->i_atime = inode->i_mtime = inode->i_ctime; 91 78 inode->i_blocks = 0; 92 79 inode->i_generation = vnode->fid.unique; 93 80 inode->i_version = vnode->status.data_version; 94 81 inode->i_mapping->a_ops = &afs_fs_aops; 95 - 96 - /* check to see whether a symbolic link is really a mountpoint */ 97 - if (vnode->status.type == AFS_FTYPE_SYMLINK) { 98 - afs_mntpt_check_symlink(vnode, key); 99 - 100 - if (test_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags)) { 101 - inode->i_mode = S_IFDIR | vnode->status.mode; 102 - inode->i_op = &afs_mntpt_inode_operations; 103 - inode->i_fop = &afs_mntpt_file_operations; 104 - } 105 - } 106 - 107 82 return 0; 108 83 } 109 84 ··· 246 245 vnode->cb_version = 0; 247 246 vnode->cb_expiry = 0; 248 247 vnode->cb_type = 0; 249 - vnode->cb_expires = get_seconds(); 248 + vnode->cb_expires = ktime_get_real_seconds(); 250 249 } else { 251 250 vnode->cb_version = cb->version; 252 251 vnode->cb_expiry = cb->expiry; 253 252 vnode->cb_type = cb->type; 254 - vnode->cb_expires = vnode->cb_expiry + get_seconds(); 253 + vnode->cb_expires = vnode->cb_expiry + 254 + ktime_get_real_seconds(); 255 255 } 256 256 } 257 257 ··· 325 323 !test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags) && 326 324 !test_bit(AFS_VNODE_MODIFIED, &vnode->flags) && 327 325 !test_bit(AFS_VNODE_ZAP_DATA, &vnode->flags)) { 328 - if (vnode->cb_expires < get_seconds() + 10) { 326 + if (vnode->cb_expires < ktime_get_real_seconds() + 10) { 329 327 _debug("callback expired"); 330 328 set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags); 331 329 } else { ··· 446 444 447 445 mutex_lock(&vnode->permits_lock); 448 446 permits = vnode->permits; 449 - rcu_assign_pointer(vnode->permits, NULL); 447 + RCU_INIT_POINTER(vnode->permits, NULL); 450 448 mutex_unlock(&vnode->permits_lock); 451 449 if (permits) 452 450 call_rcu(&permits->rcu, afs_zap_permits);
+13 -10
fs/afs/internal.h
··· 11 11 12 12 #include <linux/compiler.h> 13 13 #include <linux/kernel.h> 14 + #include <linux/ktime.h> 14 15 #include <linux/fs.h> 15 16 #include <linux/pagemap.h> 16 17 #include <linux/rxrpc.h> ··· 91 90 unsigned request_size; /* size of request data */ 92 91 unsigned reply_max; /* maximum size of reply */ 93 92 unsigned first_offset; /* offset into mapping[first] */ 94 - unsigned last_to; /* amount of mapping[last] */ 93 + union { 94 + unsigned last_to; /* amount of mapping[last] */ 95 + unsigned count2; /* count used in unmarshalling */ 96 + }; 95 97 unsigned char unmarshall; /* unmarshalling phase */ 96 98 bool incoming; /* T if incoming call */ 97 99 bool send_pages; /* T if data from mapping should be sent */ ··· 131 127 */ 132 128 struct afs_read { 133 129 loff_t pos; /* Where to start reading */ 134 - loff_t len; /* How much to read */ 130 + loff_t len; /* How much we're asking for */ 135 131 loff_t actual_len; /* How much we're actually getting */ 132 + loff_t remain; /* Amount remaining */ 136 133 atomic_t usage; 137 - unsigned int remain; /* Amount remaining */ 138 134 unsigned int index; /* Which page we're reading into */ 139 - unsigned int pg_offset; /* Offset in page we're at */ 140 135 unsigned int nr_pages; 141 136 void (*page_done)(struct afs_call *, struct afs_read *); 142 137 struct page *pages[]; ··· 250 247 */ 251 248 struct afs_vlocation { 252 249 atomic_t usage; 253 - time_t time_of_death; /* time at which put reduced usage to 0 */ 250 + time64_t time_of_death; /* time at which put reduced usage to 0 */ 254 251 struct list_head link; /* link in cell volume location list */ 255 252 struct list_head grave; /* link in master graveyard list */ 256 253 struct list_head update; /* link in master update list */ ··· 261 258 struct afs_cache_vlocation vldb; /* volume information DB record */ 262 259 struct afs_volume *vols[3]; /* volume access record pointer (index by type) */ 263 260 wait_queue_head_t waitq; /* status change waitqueue */ 264 - time_t update_at; /* time at which record should be updated */ 261 + time64_t update_at; /* time at which record should be updated */ 265 262 spinlock_t lock; /* access lock */ 266 263 afs_vlocation_state_t state; /* volume location state */ 267 264 unsigned short upd_rej_cnt; /* ENOMEDIUM count during update */ ··· 274 271 */ 275 272 struct afs_server { 276 273 atomic_t usage; 277 - time_t time_of_death; /* time at which put reduced usage to 0 */ 274 + time64_t time_of_death; /* time at which put reduced usage to 0 */ 278 275 struct in_addr addr; /* server address */ 279 276 struct afs_cell *cell; /* cell in which server resides */ 280 277 struct list_head link; /* link in cell's server list */ ··· 377 374 struct rb_node server_rb; /* link in server->fs_vnodes */ 378 375 struct rb_node cb_promise; /* link in server->cb_promises */ 379 376 struct work_struct cb_broken_work; /* work to be done on callback break */ 380 - time_t cb_expires; /* time at which callback expires */ 381 - time_t cb_expires_at; /* time used to order cb_promise */ 377 + time64_t cb_expires; /* time at which callback expires */ 378 + time64_t cb_expires_at; /* time used to order cb_promise */ 382 379 unsigned cb_version; /* callback version */ 383 380 unsigned cb_expiry; /* callback expiry time */ 384 381 afs_callback_type_t cb_type; /* type of callback */ ··· 560 557 extern const struct file_operations afs_mntpt_file_operations; 561 558 562 559 extern struct vfsmount *afs_d_automount(struct path *); 563 - extern int afs_mntpt_check_symlink(struct afs_vnode *, struct key *); 564 560 extern void afs_mntpt_kill_timer(void); 565 561 566 562 /* ··· 720 718 extern void afs_pages_written_back(struct afs_vnode *, struct afs_call *); 721 719 extern ssize_t afs_file_write(struct kiocb *, struct iov_iter *); 722 720 extern int afs_writeback_all(struct afs_vnode *); 721 + extern int afs_flush(struct file *, fl_owner_t); 723 722 extern int afs_fsync(struct file *, loff_t, loff_t, int); 724 723 725 724
+2
fs/afs/misc.c
··· 84 84 case RXKADDATALEN: return -EKEYREJECTED; 85 85 case RXKADILLEGALLEVEL: return -EKEYREJECTED; 86 86 87 + case RXGEN_OPCODE: return -ENOTSUPP; 88 + 87 89 default: return -EREMOTEIO; 88 90 } 89 91 }
-53
fs/afs/mntpt.c
··· 47 47 static unsigned long afs_mntpt_expiry_timeout = 10 * 60; 48 48 49 49 /* 50 - * check a symbolic link to see whether it actually encodes a mountpoint 51 - * - sets the AFS_VNODE_MOUNTPOINT flag on the vnode appropriately 52 - */ 53 - int afs_mntpt_check_symlink(struct afs_vnode *vnode, struct key *key) 54 - { 55 - struct page *page; 56 - size_t size; 57 - char *buf; 58 - int ret; 59 - 60 - _enter("{%x:%u,%u}", 61 - vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique); 62 - 63 - /* read the contents of the symlink into the pagecache */ 64 - page = read_cache_page(AFS_VNODE_TO_I(vnode)->i_mapping, 0, 65 - afs_page_filler, key); 66 - if (IS_ERR(page)) { 67 - ret = PTR_ERR(page); 68 - goto out; 69 - } 70 - 71 - ret = -EIO; 72 - if (PageError(page)) 73 - goto out_free; 74 - 75 - buf = kmap(page); 76 - 77 - /* examine the symlink's contents */ 78 - size = vnode->status.size; 79 - _debug("symlink to %*.*s", (int) size, (int) size, buf); 80 - 81 - if (size > 2 && 82 - (buf[0] == '%' || buf[0] == '#') && 83 - buf[size - 1] == '.' 84 - ) { 85 - _debug("symlink is a mountpoint"); 86 - spin_lock(&vnode->lock); 87 - set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags); 88 - vnode->vfs_inode.i_flags |= S_AUTOMOUNT; 89 - spin_unlock(&vnode->lock); 90 - } 91 - 92 - ret = 0; 93 - 94 - kunmap(page); 95 - out_free: 96 - put_page(page); 97 - out: 98 - _leave(" = %d", ret); 99 - return ret; 100 - } 101 - 102 - /* 103 50 * no valid lookup procedure on this sort of dir 104 51 */ 105 52 static struct dentry *afs_mntpt_lookup(struct inode *dir,
+83 -64
fs/afs/rxrpc.c
··· 259 259 call->buffer = NULL; 260 260 } 261 261 262 + #define AFS_BVEC_MAX 8 263 + 264 + /* 265 + * Load the given bvec with the next few pages. 266 + */ 267 + static void afs_load_bvec(struct afs_call *call, struct msghdr *msg, 268 + struct bio_vec *bv, pgoff_t first, pgoff_t last, 269 + unsigned offset) 270 + { 271 + struct page *pages[AFS_BVEC_MAX]; 272 + unsigned int nr, n, i, to, bytes = 0; 273 + 274 + nr = min_t(pgoff_t, last - first + 1, AFS_BVEC_MAX); 275 + n = find_get_pages_contig(call->mapping, first, nr, pages); 276 + ASSERTCMP(n, ==, nr); 277 + 278 + msg->msg_flags |= MSG_MORE; 279 + for (i = 0; i < nr; i++) { 280 + to = PAGE_SIZE; 281 + if (first + i >= last) { 282 + to = call->last_to; 283 + msg->msg_flags &= ~MSG_MORE; 284 + } 285 + bv[i].bv_page = pages[i]; 286 + bv[i].bv_len = to - offset; 287 + bv[i].bv_offset = offset; 288 + bytes += to - offset; 289 + offset = 0; 290 + } 291 + 292 + iov_iter_bvec(&msg->msg_iter, WRITE | ITER_BVEC, bv, nr, bytes); 293 + } 294 + 262 295 /* 263 296 * attach the data from a bunch of pages on an inode to a call 264 297 */ 265 298 static int afs_send_pages(struct afs_call *call, struct msghdr *msg) 266 299 { 267 - struct page *pages[8]; 268 - unsigned count, n, loop, offset, to; 300 + struct bio_vec bv[AFS_BVEC_MAX]; 301 + unsigned int bytes, nr, loop, offset; 269 302 pgoff_t first = call->first, last = call->last; 270 303 int ret; 271 - 272 - _enter(""); 273 304 274 305 offset = call->first_offset; 275 306 call->first_offset = 0; 276 307 277 308 do { 278 - _debug("attach %lx-%lx", first, last); 309 + afs_load_bvec(call, msg, bv, first, last, offset); 310 + offset = 0; 311 + bytes = msg->msg_iter.count; 312 + nr = msg->msg_iter.nr_segs; 279 313 280 - count = last - first + 1; 281 - if (count > ARRAY_SIZE(pages)) 282 - count = ARRAY_SIZE(pages); 283 - n = find_get_pages_contig(call->mapping, first, count, pages); 284 - ASSERTCMP(n, ==, count); 285 - 286 - loop = 0; 287 - do { 288 - struct bio_vec bvec = {.bv_page = pages[loop], 289 - .bv_offset = offset}; 290 - msg->msg_flags = 0; 291 - to = PAGE_SIZE; 292 - if (first + loop >= last) 293 - to = call->last_to; 294 - else 295 - msg->msg_flags = MSG_MORE; 296 - bvec.bv_len = to - offset; 297 - offset = 0; 298 - 299 - _debug("- range %u-%u%s", 300 - offset, to, msg->msg_flags ? " [more]" : ""); 301 - iov_iter_bvec(&msg->msg_iter, WRITE | ITER_BVEC, 302 - &bvec, 1, to - offset); 303 - 304 - /* have to change the state *before* sending the last 305 - * packet as RxRPC might give us the reply before it 306 - * returns from sending the request */ 307 - if (first + loop >= last) 308 - call->state = AFS_CALL_AWAIT_REPLY; 309 - ret = rxrpc_kernel_send_data(afs_socket, call->rxcall, 310 - msg, to - offset); 311 - if (ret < 0) 312 - break; 313 - } while (++loop < count); 314 - first += count; 315 - 316 - for (loop = 0; loop < count; loop++) 317 - put_page(pages[loop]); 314 + /* Have to change the state *before* sending the last 315 + * packet as RxRPC might give us the reply before it 316 + * returns from sending the request. 317 + */ 318 + if (first + nr - 1 >= last) 319 + call->state = AFS_CALL_AWAIT_REPLY; 320 + ret = rxrpc_kernel_send_data(afs_socket, call->rxcall, 321 + msg, bytes); 322 + for (loop = 0; loop < nr; loop++) 323 + put_page(bv[loop].bv_page); 318 324 if (ret < 0) 319 325 break; 326 + 327 + first += nr; 320 328 } while (first <= last); 321 329 322 - _leave(" = %d", ret); 323 330 return ret; 324 331 } 325 332 ··· 340 333 struct rxrpc_call *rxcall; 341 334 struct msghdr msg; 342 335 struct kvec iov[1]; 336 + size_t offset; 337 + u32 abort_code; 343 338 int ret; 344 339 345 340 _enter("%x,{%d},", addr->s_addr, ntohs(call->port)); ··· 390 381 msg.msg_controllen = 0; 391 382 msg.msg_flags = (call->send_pages ? MSG_MORE : 0); 392 383 393 - /* have to change the state *before* sending the last packet as RxRPC 394 - * might give us the reply before it returns from sending the 395 - * request */ 384 + /* We have to change the state *before* sending the last packet as 385 + * rxrpc might give us the reply before it returns from sending the 386 + * request. Further, if the send fails, we may already have been given 387 + * a notification and may have collected it. 388 + */ 396 389 if (!call->send_pages) 397 390 call->state = AFS_CALL_AWAIT_REPLY; 398 391 ret = rxrpc_kernel_send_data(afs_socket, rxcall, ··· 416 405 return afs_wait_for_call_to_complete(call); 417 406 418 407 error_do_abort: 419 - rxrpc_kernel_abort_call(afs_socket, rxcall, RX_USER_ABORT, -ret, "KSD"); 408 + call->state = AFS_CALL_COMPLETE; 409 + if (ret != -ECONNABORTED) { 410 + rxrpc_kernel_abort_call(afs_socket, rxcall, RX_USER_ABORT, 411 + -ret, "KSD"); 412 + } else { 413 + abort_code = 0; 414 + offset = 0; 415 + rxrpc_kernel_recv_data(afs_socket, rxcall, NULL, 0, &offset, 416 + false, &abort_code); 417 + ret = call->type->abort_to_error(abort_code); 418 + } 420 419 error_kill_call: 421 420 afs_put_call(call); 422 421 _leave(" = %d", ret); ··· 473 452 case -EINPROGRESS: 474 453 case -EAGAIN: 475 454 goto out; 455 + case -ECONNABORTED: 456 + goto call_complete; 476 457 case -ENOTCONN: 477 458 abort_code = RX_CALL_DEAD; 478 459 rxrpc_kernel_abort_call(afs_socket, call->rxcall, 479 460 abort_code, -ret, "KNC"); 480 - goto do_abort; 461 + goto save_error; 481 462 case -ENOTSUPP: 482 - abort_code = RX_INVALID_OPERATION; 463 + abort_code = RXGEN_OPCODE; 483 464 rxrpc_kernel_abort_call(afs_socket, call->rxcall, 484 465 abort_code, -ret, "KIV"); 485 - goto do_abort; 466 + goto save_error; 486 467 case -ENODATA: 487 468 case -EBADMSG: 488 469 case -EMSGSIZE: ··· 494 471 abort_code = RXGEN_SS_UNMARSHAL; 495 472 rxrpc_kernel_abort_call(afs_socket, call->rxcall, 496 473 abort_code, EBADMSG, "KUM"); 497 - goto do_abort; 474 + goto save_error; 498 475 } 499 476 } 500 477 ··· 505 482 _leave(""); 506 483 return; 507 484 508 - do_abort: 485 + save_error: 509 486 call->error = ret; 487 + call_complete: 510 488 call->state = AFS_CALL_COMPLETE; 511 489 goto done; 512 490 } ··· 517 493 */ 518 494 static int afs_wait_for_call_to_complete(struct afs_call *call) 519 495 { 520 - const char *abort_why; 521 496 int ret; 522 497 523 498 DECLARE_WAITQUEUE(myself, current); ··· 535 512 continue; 536 513 } 537 514 538 - abort_why = "KWC"; 539 - ret = call->error; 540 - if (call->state == AFS_CALL_COMPLETE) 541 - break; 542 - abort_why = "KWI"; 543 - ret = -EINTR; 544 - if (signal_pending(current)) 515 + if (call->state == AFS_CALL_COMPLETE || 516 + signal_pending(current)) 545 517 break; 546 518 schedule(); 547 519 } ··· 544 526 remove_wait_queue(&call->waitq, &myself); 545 527 __set_current_state(TASK_RUNNING); 546 528 547 - /* kill the call */ 529 + /* Kill off the call if it's still live. */ 548 530 if (call->state < AFS_CALL_COMPLETE) { 549 - _debug("call incomplete"); 531 + _debug("call interrupted"); 550 532 rxrpc_kernel_abort_call(afs_socket, call->rxcall, 551 - RX_CALL_DEAD, -ret, abort_why); 533 + RX_USER_ABORT, -EINTR, "KWI"); 552 534 } 553 535 536 + ret = call->error; 554 537 _debug("call complete"); 555 538 afs_put_call(call); 556 539 _leave(" = %d", ret);
+7 -2
fs/afs/security.c
··· 114 114 115 115 mutex_lock(&vnode->permits_lock); 116 116 permits = vnode->permits; 117 - rcu_assign_pointer(vnode->permits, NULL); 117 + RCU_INIT_POINTER(vnode->permits, NULL); 118 118 mutex_unlock(&vnode->permits_lock); 119 119 120 120 if (permits) ··· 340 340 } else { 341 341 if (!(access & AFS_ACE_LOOKUP)) 342 342 goto permission_denied; 343 + if ((mask & MAY_EXEC) && !(inode->i_mode & S_IXUSR)) 344 + goto permission_denied; 343 345 if (mask & (MAY_EXEC | MAY_READ)) { 344 346 if (!(access & AFS_ACE_READ)) 345 347 goto permission_denied; 348 + if (!(inode->i_mode & S_IRUSR)) 349 + goto permission_denied; 346 350 } else if (mask & MAY_WRITE) { 347 351 if (!(access & AFS_ACE_WRITE)) 352 + goto permission_denied; 353 + if (!(inode->i_mode & S_IWUSR)) 348 354 goto permission_denied; 349 355 } 350 356 } 351 357 352 358 key_put(key); 353 - ret = generic_permission(inode, mask); 354 359 _leave(" = %d", ret); 355 360 return ret; 356 361
+3 -3
fs/afs/server.c
··· 242 242 spin_lock(&afs_server_graveyard_lock); 243 243 if (atomic_read(&server->usage) == 0) { 244 244 list_move_tail(&server->grave, &afs_server_graveyard); 245 - server->time_of_death = get_seconds(); 245 + server->time_of_death = ktime_get_real_seconds(); 246 246 queue_delayed_work(afs_wq, &afs_server_reaper, 247 247 afs_server_timeout * HZ); 248 248 } ··· 277 277 LIST_HEAD(corpses); 278 278 struct afs_server *server; 279 279 unsigned long delay, expiry; 280 - time_t now; 280 + time64_t now; 281 281 282 - now = get_seconds(); 282 + now = ktime_get_real_seconds(); 283 283 spin_lock(&afs_server_graveyard_lock); 284 284 285 285 while (!list_empty(&afs_server_graveyard)) {
+9 -7
fs/afs/vlocation.c
··· 340 340 struct afs_vlocation *xvl; 341 341 342 342 /* wait at least 10 minutes before updating... */ 343 - vl->update_at = get_seconds() + afs_vlocation_update_timeout; 343 + vl->update_at = ktime_get_real_seconds() + 344 + afs_vlocation_update_timeout; 344 345 345 346 spin_lock(&afs_vlocation_updates_lock); 346 347 ··· 507 506 if (atomic_read(&vl->usage) == 0) { 508 507 _debug("buried"); 509 508 list_move_tail(&vl->grave, &afs_vlocation_graveyard); 510 - vl->time_of_death = get_seconds(); 509 + vl->time_of_death = ktime_get_real_seconds(); 511 510 queue_delayed_work(afs_wq, &afs_vlocation_reap, 512 511 afs_vlocation_timeout * HZ); 513 512 ··· 544 543 LIST_HEAD(corpses); 545 544 struct afs_vlocation *vl; 546 545 unsigned long delay, expiry; 547 - time_t now; 546 + time64_t now; 548 547 549 548 _enter(""); 550 549 551 - now = get_seconds(); 550 + now = ktime_get_real_seconds(); 552 551 spin_lock(&afs_vlocation_graveyard_lock); 553 552 554 553 while (!list_empty(&afs_vlocation_graveyard)) { ··· 623 622 { 624 623 struct afs_cache_vlocation vldb; 625 624 struct afs_vlocation *vl, *xvl; 626 - time_t now; 625 + time64_t now; 627 626 long timeout; 628 627 int ret; 629 628 630 629 _enter(""); 631 630 632 - now = get_seconds(); 631 + now = ktime_get_real_seconds(); 633 632 634 633 /* find a record to update */ 635 634 spin_lock(&afs_vlocation_updates_lock); ··· 685 684 686 685 /* and then reschedule */ 687 686 _debug("reschedule"); 688 - vl->update_at = get_seconds() + afs_vlocation_update_timeout; 687 + vl->update_at = ktime_get_real_seconds() + 688 + afs_vlocation_update_timeout; 689 689 690 690 spin_lock(&afs_vlocation_updates_lock); 691 691
+54 -22
fs/afs/write.c
··· 84 84 * partly or wholly fill a page that's under preparation for writing 85 85 */ 86 86 static int afs_fill_page(struct afs_vnode *vnode, struct key *key, 87 - loff_t pos, struct page *page) 87 + loff_t pos, unsigned int len, struct page *page) 88 88 { 89 89 struct afs_read *req; 90 - loff_t i_size; 91 90 int ret; 92 91 93 92 _enter(",,%llu", (unsigned long long)pos); ··· 98 99 99 100 atomic_set(&req->usage, 1); 100 101 req->pos = pos; 102 + req->len = len; 101 103 req->nr_pages = 1; 102 104 req->pages[0] = page; 103 - 104 - i_size = i_size_read(&vnode->vfs_inode); 105 - if (pos + PAGE_SIZE > i_size) 106 - req->len = i_size - pos; 107 - else 108 - req->len = PAGE_SIZE; 105 + get_page(page); 109 106 110 107 ret = afs_vnode_fetch_data(vnode, key, req); 111 108 afs_put_read(req); ··· 154 159 kfree(candidate); 155 160 return -ENOMEM; 156 161 } 157 - *pagep = page; 158 - /* page won't leak in error case: it eventually gets cleaned off LRU */ 159 162 160 163 if (!PageUptodate(page) && len != PAGE_SIZE) { 161 - ret = afs_fill_page(vnode, key, index << PAGE_SHIFT, page); 164 + ret = afs_fill_page(vnode, key, pos & PAGE_MASK, PAGE_SIZE, page); 162 165 if (ret < 0) { 166 + unlock_page(page); 167 + put_page(page); 163 168 kfree(candidate); 164 169 _leave(" = %d [prep]", ret); 165 170 return ret; 166 171 } 167 172 SetPageUptodate(page); 168 173 } 174 + 175 + /* page won't leak in error case: it eventually gets cleaned off LRU */ 176 + *pagep = page; 169 177 170 178 try_again: 171 179 spin_lock(&vnode->writeback_lock); ··· 231 233 if (wb->state == AFS_WBACK_PENDING) 232 234 wb->state = AFS_WBACK_CONFLICTING; 233 235 spin_unlock(&vnode->writeback_lock); 234 - if (PageDirty(page)) { 236 + if (clear_page_dirty_for_io(page)) { 235 237 ret = afs_write_back_from_locked_page(wb, page); 236 238 if (ret < 0) { 237 239 afs_put_writeback(candidate); ··· 255 257 struct page *page, void *fsdata) 256 258 { 257 259 struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); 260 + struct key *key = file->private_data; 258 261 loff_t i_size, maybe_i_size; 262 + int ret; 259 263 260 264 _enter("{%x:%u},{%lx}", 261 265 vnode->fid.vid, vnode->fid.vnode, page->index); ··· 271 271 if (maybe_i_size > i_size) 272 272 i_size_write(&vnode->vfs_inode, maybe_i_size); 273 273 spin_unlock(&vnode->writeback_lock); 274 + } 275 + 276 + if (!PageUptodate(page)) { 277 + if (copied < len) { 278 + /* Try and load any missing data from the server. The 279 + * unmarshalling routine will take care of clearing any 280 + * bits that are beyond the EOF. 281 + */ 282 + ret = afs_fill_page(vnode, key, pos + copied, 283 + len - copied, page); 284 + if (ret < 0) 285 + return ret; 286 + } 287 + SetPageUptodate(page); 274 288 } 275 289 276 290 set_page_dirty(page); ··· 321 307 ASSERTCMP(pv.nr, ==, count); 322 308 323 309 for (loop = 0; loop < count; loop++) { 324 - ClearPageUptodate(pv.pages[loop]); 310 + struct page *page = pv.pages[loop]; 311 + ClearPageUptodate(page); 325 312 if (error) 326 - SetPageError(pv.pages[loop]); 327 - end_page_writeback(pv.pages[loop]); 313 + SetPageError(page); 314 + if (PageWriteback(page)) 315 + end_page_writeback(page); 316 + if (page->index >= first) 317 + first = page->index + 1; 328 318 } 329 319 330 320 __pagevec_release(&pv); ··· 353 335 _enter(",%lx", primary_page->index); 354 336 355 337 count = 1; 356 - if (!clear_page_dirty_for_io(primary_page)) 357 - BUG(); 358 338 if (test_set_page_writeback(primary_page)) 359 339 BUG(); 360 340 ··· 518 502 */ 519 503 lock_page(page); 520 504 521 - if (page->mapping != mapping) { 505 + if (page->mapping != mapping || !PageDirty(page)) { 522 506 unlock_page(page); 523 507 put_page(page); 524 508 continue; 525 509 } 526 510 527 - if (wbc->sync_mode != WB_SYNC_NONE) 528 - wait_on_page_writeback(page); 529 - 530 - if (PageWriteback(page) || !PageDirty(page)) { 511 + if (PageWriteback(page)) { 531 512 unlock_page(page); 513 + if (wbc->sync_mode != WB_SYNC_NONE) 514 + wait_on_page_writeback(page); 515 + put_page(page); 532 516 continue; 533 517 } 534 518 ··· 539 523 wb->state = AFS_WBACK_WRITING; 540 524 spin_unlock(&wb->vnode->writeback_lock); 541 525 526 + if (!clear_page_dirty_for_io(page)) 527 + BUG(); 542 528 ret = afs_write_back_from_locked_page(wb, page); 543 529 unlock_page(page); 544 530 put_page(page); ··· 761 743 out: 762 744 inode_unlock(inode); 763 745 return ret; 746 + } 747 + 748 + /* 749 + * Flush out all outstanding writes on a file opened for writing when it is 750 + * closed. 751 + */ 752 + int afs_flush(struct file *file, fl_owner_t id) 753 + { 754 + _enter(""); 755 + 756 + if ((file->f_mode & FMODE_WRITE) == 0) 757 + return 0; 758 + 759 + return vfs_fsync(file, 0); 764 760 } 765 761 766 762 /*