Commit | Line | Data |
---|---|---|
08e0e7c8 | 1 | /* AFS File Server client stubs |
1da177e4 | 2 | * |
08e0e7c8 | 3 | * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved. |
1da177e4 LT |
4 | * Written by David Howells (dhowells@redhat.com) |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU General Public License | |
8 | * as published by the Free Software Foundation; either version | |
9 | * 2 of the License, or (at your option) any later version. | |
10 | */ | |
11 | ||
12 | #include <linux/init.h> | |
5a0e3ad6 | 13 | #include <linux/slab.h> |
1da177e4 | 14 | #include <linux/sched.h> |
08e0e7c8 | 15 | #include <linux/circ_buf.h> |
a01179e6 | 16 | #include <linux/iversion.h> |
1da177e4 | 17 | #include "internal.h" |
08e0e7c8 | 18 | #include "afs_fs.h" |
dd9fbcb8 | 19 | #include "xdr_fs.h" |
1da177e4 | 20 | |
025db80c DH |
21 | static const struct afs_fid afs_zero_fid; |
22 | ||
6db3ac3c DH |
23 | /* |
24 | * We need somewhere to discard into in case the server helpfully returns more | |
25 | * than we asked for in FS.FetchData{,64}. | |
26 | */ | |
27 | static u8 afs_discard_buffer[64]; | |
28 | ||
d2ddc776 | 29 | static inline void afs_use_fs_server(struct afs_call *call, struct afs_cb_interest *cbi) |
c435ee34 | 30 | { |
d2ddc776 | 31 | call->cbi = afs_get_cb_interest(cbi); |
c435ee34 DH |
32 | } |
33 | ||
260a9803 DH |
34 | /* |
35 | * decode an AFSFid block | |
36 | */ | |
37 | static void xdr_decode_AFSFid(const __be32 **_bp, struct afs_fid *fid) | |
38 | { | |
39 | const __be32 *bp = *_bp; | |
40 | ||
41 | fid->vid = ntohl(*bp++); | |
42 | fid->vnode = ntohl(*bp++); | |
43 | fid->unique = ntohl(*bp++); | |
44 | *_bp = bp; | |
45 | } | |
46 | ||
888b3384 DH |
47 | /* |
48 | * Dump a bad file status record. | |
49 | */ | |
50 | static void xdr_dump_bad(const __be32 *bp) | |
51 | { | |
52 | __be32 x[4]; | |
53 | int i; | |
54 | ||
55 | pr_notice("AFS XDR: Bad status record\n"); | |
56 | for (i = 0; i < 5 * 4 * 4; i += 16) { | |
57 | memcpy(x, bp, 16); | |
58 | bp += 4; | |
59 | pr_notice("%03x: %08x %08x %08x %08x\n", | |
60 | i, ntohl(x[0]), ntohl(x[1]), ntohl(x[2]), ntohl(x[3])); | |
61 | } | |
62 | ||
63 | memcpy(x, bp, 4); | |
64 | pr_notice("0x50: %08x\n", ntohl(x[0])); | |
65 | } | |
66 | ||
1da177e4 | 67 | /* |
dd9fbcb8 | 68 | * Update the core inode struct from a returned status record. |
1da177e4 | 69 | */ |
dd9fbcb8 DH |
70 | void afs_update_inode_from_status(struct afs_vnode *vnode, |
71 | struct afs_file_status *status, | |
72 | const afs_dataversion_t *expected_version, | |
73 | u8 flags) | |
1da177e4 | 74 | { |
95582b00 | 75 | struct timespec64 t; |
08e0e7c8 | 76 | umode_t mode; |
dd9fbcb8 DH |
77 | |
78 | t.tv_sec = status->mtime_client; | |
79 | t.tv_nsec = 0; | |
80 | vnode->vfs_inode.i_ctime = t; | |
81 | vnode->vfs_inode.i_mtime = t; | |
82 | vnode->vfs_inode.i_atime = t; | |
83 | ||
84 | if (flags & (AFS_VNODE_META_CHANGED | AFS_VNODE_NOT_YET_SET)) { | |
85 | vnode->vfs_inode.i_uid = make_kuid(&init_user_ns, status->owner); | |
86 | vnode->vfs_inode.i_gid = make_kgid(&init_user_ns, status->group); | |
87 | set_nlink(&vnode->vfs_inode, status->nlink); | |
88 | ||
89 | mode = vnode->vfs_inode.i_mode; | |
90 | mode &= ~S_IALLUGO; | |
91 | mode |= status->mode; | |
92 | barrier(); | |
93 | vnode->vfs_inode.i_mode = mode; | |
94 | } | |
95 | ||
96 | if (!(flags & AFS_VNODE_NOT_YET_SET)) { | |
97 | if (expected_version && | |
98 | *expected_version != status->data_version) { | |
99 | _debug("vnode modified %llx on {%x:%u} [exp %llx]", | |
100 | (unsigned long long) status->data_version, | |
101 | vnode->fid.vid, vnode->fid.vnode, | |
102 | (unsigned long long) *expected_version); | |
a4ff7401 | 103 | vnode->invalid_before = status->data_version; |
f3ddee8d DH |
104 | if (vnode->status.type == AFS_FTYPE_DIR) { |
105 | if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags)) | |
106 | afs_stat_v(vnode, n_inval); | |
107 | } else { | |
108 | set_bit(AFS_VNODE_ZAP_DATA, &vnode->flags); | |
109 | } | |
63a4681f DH |
110 | } else if (vnode->status.type == AFS_FTYPE_DIR) { |
111 | /* Expected directory change is handled elsewhere so | |
112 | * that we can locally edit the directory and save on a | |
113 | * download. | |
114 | */ | |
115 | if (test_bit(AFS_VNODE_DIR_VALID, &vnode->flags)) | |
116 | flags &= ~AFS_VNODE_DATA_CHANGED; | |
dd9fbcb8 DH |
117 | } |
118 | } | |
119 | ||
120 | if (flags & (AFS_VNODE_DATA_CHANGED | AFS_VNODE_NOT_YET_SET)) { | |
121 | inode_set_iversion_raw(&vnode->vfs_inode, status->data_version); | |
122 | i_size_write(&vnode->vfs_inode, status->size); | |
123 | } | |
124 | } | |
125 | ||
126 | /* | |
127 | * decode an AFSFetchStatus block | |
128 | */ | |
5f702c8e DH |
129 | static int xdr_decode_AFSFetchStatus(struct afs_call *call, |
130 | const __be32 **_bp, | |
dd9fbcb8 DH |
131 | struct afs_file_status *status, |
132 | struct afs_vnode *vnode, | |
133 | const afs_dataversion_t *expected_version, | |
f3ddee8d | 134 | struct afs_read *read_req) |
dd9fbcb8 DH |
135 | { |
136 | const struct afs_xdr_AFSFetchStatus *xdr = (const void *)*_bp; | |
684b0f68 | 137 | bool inline_error = (call->operation_ID == afs_FS_InlineBulkStatus); |
260a9803 | 138 | u64 data_version, size; |
dd9fbcb8 DH |
139 | u32 type, abort_code; |
140 | u8 flags = 0; | |
141 | int ret; | |
08e0e7c8 | 142 | |
d2ddc776 DH |
143 | if (vnode) |
144 | write_seqlock(&vnode->cb_lock); | |
c435ee34 | 145 | |
684b0f68 DH |
146 | abort_code = ntohl(xdr->abort_code); |
147 | ||
dd9fbcb8 | 148 | if (xdr->if_version != htonl(AFS_FSTATUS_VERSION)) { |
684b0f68 DH |
149 | if (xdr->if_version == htonl(0) && |
150 | abort_code != 0 && | |
151 | inline_error) { | |
152 | /* The OpenAFS fileserver has a bug in FS.InlineBulkStatus | |
153 | * whereby it doesn't set the interface version in the error | |
154 | * case. | |
155 | */ | |
156 | status->abort_code = abort_code; | |
157 | ret = 0; | |
158 | goto out; | |
159 | } | |
160 | ||
dd9fbcb8 DH |
161 | pr_warn("Unknown AFSFetchStatus version %u\n", ntohl(xdr->if_version)); |
162 | goto bad; | |
163 | } | |
08e0e7c8 | 164 | |
684b0f68 DH |
165 | if (abort_code != 0 && inline_error) { |
166 | status->abort_code = abort_code; | |
167 | ret = 0; | |
168 | goto out; | |
169 | } | |
170 | ||
dd9fbcb8 | 171 | type = ntohl(xdr->type); |
dd9fbcb8 | 172 | switch (type) { |
888b3384 DH |
173 | case AFS_FTYPE_FILE: |
174 | case AFS_FTYPE_DIR: | |
175 | case AFS_FTYPE_SYMLINK: | |
dd9fbcb8 DH |
176 | if (type != status->type && |
177 | vnode && | |
178 | !test_bit(AFS_VNODE_UNSET, &vnode->flags)) { | |
179 | pr_warning("Vnode %x:%x:%x changed type %u to %u\n", | |
180 | vnode->fid.vid, | |
181 | vnode->fid.vnode, | |
182 | vnode->fid.unique, | |
183 | status->type, type); | |
184 | goto bad; | |
185 | } | |
186 | status->type = type; | |
888b3384 | 187 | break; |
888b3384 | 188 | default: |
dd9fbcb8 | 189 | goto bad; |
888b3384 DH |
190 | } |
191 | ||
dd9fbcb8 DH |
192 | #define EXTRACT_M(FIELD) \ |
193 | do { \ | |
194 | u32 x = ntohl(xdr->FIELD); \ | |
195 | if (status->FIELD != x) { \ | |
196 | flags |= AFS_VNODE_META_CHANGED; \ | |
197 | status->FIELD = x; \ | |
198 | } \ | |
199 | } while (0) | |
200 | ||
201 | EXTRACT_M(nlink); | |
202 | EXTRACT_M(author); | |
203 | EXTRACT_M(owner); | |
204 | EXTRACT_M(caller_access); /* call ticket dependent */ | |
205 | EXTRACT_M(anon_access); | |
206 | EXTRACT_M(mode); | |
207 | EXTRACT_M(group); | |
208 | ||
209 | status->mtime_client = ntohl(xdr->mtime_client); | |
210 | status->mtime_server = ntohl(xdr->mtime_server); | |
211 | status->lock_count = ntohl(xdr->lock_count); | |
212 | ||
213 | size = (u64)ntohl(xdr->size_lo); | |
214 | size |= (u64)ntohl(xdr->size_hi) << 32; | |
63a4681f | 215 | status->size = size; |
dd9fbcb8 DH |
216 | |
217 | data_version = (u64)ntohl(xdr->data_version_lo); | |
218 | data_version |= (u64)ntohl(xdr->data_version_hi) << 32; | |
219 | if (data_version != status->data_version) { | |
220 | status->data_version = data_version; | |
221 | flags |= AFS_VNODE_DATA_CHANGED; | |
08e0e7c8 | 222 | } |
f3ddee8d DH |
223 | |
224 | if (read_req) { | |
225 | read_req->data_version = data_version; | |
226 | read_req->file_size = size; | |
227 | } | |
08e0e7c8 | 228 | |
dd9fbcb8 | 229 | *_bp = (const void *)*_bp + sizeof(*xdr); |
260a9803 DH |
230 | |
231 | if (vnode) { | |
dd9fbcb8 DH |
232 | if (test_bit(AFS_VNODE_UNSET, &vnode->flags)) |
233 | flags |= AFS_VNODE_NOT_YET_SET; | |
234 | afs_update_inode_from_status(vnode, status, expected_version, | |
235 | flags); | |
260a9803 DH |
236 | } |
237 | ||
dd9fbcb8 | 238 | ret = 0; |
c435ee34 | 239 | |
888b3384 | 240 | out: |
d2ddc776 DH |
241 | if (vnode) |
242 | write_sequnlock(&vnode->cb_lock); | |
dd9fbcb8 DH |
243 | return ret; |
244 | ||
245 | bad: | |
246 | xdr_dump_bad(*_bp); | |
5f702c8e | 247 | ret = afs_protocol_error(call, -EBADMSG); |
dd9fbcb8 | 248 | goto out; |
ec26815a | 249 | } |
1da177e4 | 250 | |
1da177e4 | 251 | /* |
08e0e7c8 | 252 | * decode an AFSCallBack block |
1da177e4 | 253 | */ |
c435ee34 DH |
254 | static void xdr_decode_AFSCallBack(struct afs_call *call, |
255 | struct afs_vnode *vnode, | |
256 | const __be32 **_bp) | |
1da177e4 | 257 | { |
d2ddc776 | 258 | struct afs_cb_interest *old, *cbi = call->cbi; |
08e0e7c8 | 259 | const __be32 *bp = *_bp; |
c435ee34 DH |
260 | u32 cb_expiry; |
261 | ||
262 | write_seqlock(&vnode->cb_lock); | |
263 | ||
68251f0a | 264 | if (call->cb_break == afs_cb_break_sum(vnode, cbi)) { |
c435ee34 DH |
265 | vnode->cb_version = ntohl(*bp++); |
266 | cb_expiry = ntohl(*bp++); | |
267 | vnode->cb_type = ntohl(*bp++); | |
268 | vnode->cb_expires_at = cb_expiry + ktime_get_real_seconds(); | |
d2ddc776 DH |
269 | old = vnode->cb_interest; |
270 | if (old != call->cbi) { | |
271 | vnode->cb_interest = cbi; | |
272 | cbi = old; | |
273 | } | |
c435ee34 DH |
274 | set_bit(AFS_VNODE_CB_PROMISED, &vnode->flags); |
275 | } else { | |
276 | bp += 3; | |
277 | } | |
1da177e4 | 278 | |
c435ee34 | 279 | write_sequnlock(&vnode->cb_lock); |
d2ddc776 | 280 | call->cbi = cbi; |
08e0e7c8 | 281 | *_bp = bp; |
ec26815a | 282 | } |
1da177e4 | 283 | |
260a9803 DH |
284 | static void xdr_decode_AFSCallBack_raw(const __be32 **_bp, |
285 | struct afs_callback *cb) | |
286 | { | |
287 | const __be32 *bp = *_bp; | |
288 | ||
289 | cb->version = ntohl(*bp++); | |
290 | cb->expiry = ntohl(*bp++); | |
291 | cb->type = ntohl(*bp++); | |
292 | *_bp = bp; | |
293 | } | |
294 | ||
1da177e4 | 295 | /* |
08e0e7c8 | 296 | * decode an AFSVolSync block |
1da177e4 | 297 | */ |
08e0e7c8 DH |
298 | static void xdr_decode_AFSVolSync(const __be32 **_bp, |
299 | struct afs_volsync *volsync) | |
1da177e4 | 300 | { |
08e0e7c8 | 301 | const __be32 *bp = *_bp; |
1da177e4 | 302 | |
08e0e7c8 DH |
303 | volsync->creation = ntohl(*bp++); |
304 | bp++; /* spare2 */ | |
305 | bp++; /* spare3 */ | |
306 | bp++; /* spare4 */ | |
307 | bp++; /* spare5 */ | |
308 | bp++; /* spare6 */ | |
309 | *_bp = bp; | |
310 | } | |
1da177e4 | 311 | |
31143d5d DH |
312 | /* |
313 | * encode the requested attributes into an AFSStoreStatus block | |
314 | */ | |
315 | static void xdr_encode_AFS_StoreStatus(__be32 **_bp, struct iattr *attr) | |
316 | { | |
317 | __be32 *bp = *_bp; | |
318 | u32 mask = 0, mtime = 0, owner = 0, group = 0, mode = 0; | |
319 | ||
320 | mask = 0; | |
321 | if (attr->ia_valid & ATTR_MTIME) { | |
322 | mask |= AFS_SET_MTIME; | |
323 | mtime = attr->ia_mtime.tv_sec; | |
324 | } | |
325 | ||
326 | if (attr->ia_valid & ATTR_UID) { | |
327 | mask |= AFS_SET_OWNER; | |
a0a5386a | 328 | owner = from_kuid(&init_user_ns, attr->ia_uid); |
31143d5d DH |
329 | } |
330 | ||
331 | if (attr->ia_valid & ATTR_GID) { | |
332 | mask |= AFS_SET_GROUP; | |
a0a5386a | 333 | group = from_kgid(&init_user_ns, attr->ia_gid); |
31143d5d DH |
334 | } |
335 | ||
336 | if (attr->ia_valid & ATTR_MODE) { | |
337 | mask |= AFS_SET_MODE; | |
338 | mode = attr->ia_mode & S_IALLUGO; | |
339 | } | |
340 | ||
341 | *bp++ = htonl(mask); | |
342 | *bp++ = htonl(mtime); | |
343 | *bp++ = htonl(owner); | |
344 | *bp++ = htonl(group); | |
345 | *bp++ = htonl(mode); | |
346 | *bp++ = 0; /* segment size */ | |
347 | *_bp = bp; | |
348 | } | |
349 | ||
45222b9e DH |
350 | /* |
351 | * decode an AFSFetchVolumeStatus block | |
352 | */ | |
353 | static void xdr_decode_AFSFetchVolumeStatus(const __be32 **_bp, | |
354 | struct afs_volume_status *vs) | |
355 | { | |
356 | const __be32 *bp = *_bp; | |
357 | ||
358 | vs->vid = ntohl(*bp++); | |
359 | vs->parent_id = ntohl(*bp++); | |
360 | vs->online = ntohl(*bp++); | |
361 | vs->in_service = ntohl(*bp++); | |
362 | vs->blessed = ntohl(*bp++); | |
363 | vs->needs_salvage = ntohl(*bp++); | |
364 | vs->type = ntohl(*bp++); | |
365 | vs->min_quota = ntohl(*bp++); | |
366 | vs->max_quota = ntohl(*bp++); | |
367 | vs->blocks_in_use = ntohl(*bp++); | |
368 | vs->part_blocks_avail = ntohl(*bp++); | |
369 | vs->part_max_blocks = ntohl(*bp++); | |
370 | *_bp = bp; | |
371 | } | |
372 | ||
08e0e7c8 DH |
373 | /* |
374 | * deliver reply data to an FS.FetchStatus | |
375 | */ | |
5cf9dd55 | 376 | static int afs_deliver_fs_fetch_status_vnode(struct afs_call *call) |
08e0e7c8 | 377 | { |
97e3043a | 378 | struct afs_vnode *vnode = call->reply[0]; |
08e0e7c8 | 379 | const __be32 *bp; |
372ee163 | 380 | int ret; |
1da177e4 | 381 | |
d001648e | 382 | ret = afs_transfer_reply(call); |
372ee163 DH |
383 | if (ret < 0) |
384 | return ret; | |
1da177e4 | 385 | |
c435ee34 DH |
386 | _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode); |
387 | ||
08e0e7c8 DH |
388 | /* unmarshall the reply once we've received all of it */ |
389 | bp = call->buffer; | |
5f702c8e | 390 | if (xdr_decode_AFSFetchStatus(call, &bp, &vnode->status, vnode, |
dd9fbcb8 | 391 | &call->expected_version, NULL) < 0) |
5f702c8e | 392 | return afs_protocol_error(call, -EBADMSG); |
c435ee34 | 393 | xdr_decode_AFSCallBack(call, vnode, &bp); |
97e3043a DH |
394 | if (call->reply[1]) |
395 | xdr_decode_AFSVolSync(&bp, call->reply[1]); | |
1da177e4 | 396 | |
08e0e7c8 DH |
397 | _leave(" = 0 [done]"); |
398 | return 0; | |
ec26815a | 399 | } |
08e0e7c8 DH |
400 | |
401 | /* | |
402 | * FS.FetchStatus operation type | |
403 | */ | |
5cf9dd55 DH |
404 | static const struct afs_call_type afs_RXFSFetchStatus_vnode = { |
405 | .name = "FS.FetchStatus(vnode)", | |
025db80c | 406 | .op = afs_FS_FetchStatus, |
5cf9dd55 | 407 | .deliver = afs_deliver_fs_fetch_status_vnode, |
08e0e7c8 DH |
408 | .destructor = afs_flat_call_destructor, |
409 | }; | |
1da177e4 | 410 | |
1da177e4 LT |
411 | /* |
412 | * fetch the status information for a file | |
413 | */ | |
0c3a5ac2 DH |
414 | int afs_fs_fetch_file_status(struct afs_fs_cursor *fc, struct afs_volsync *volsync, |
415 | bool new_inode) | |
1da177e4 | 416 | { |
d2ddc776 | 417 | struct afs_vnode *vnode = fc->vnode; |
08e0e7c8 | 418 | struct afs_call *call; |
f044c884 | 419 | struct afs_net *net = afs_v2net(vnode); |
1da177e4 LT |
420 | __be32 *bp; |
421 | ||
416351f2 | 422 | _enter(",%x,{%x:%u},,", |
d2ddc776 | 423 | key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode); |
1da177e4 | 424 | |
5cf9dd55 DH |
425 | call = afs_alloc_flat_call(net, &afs_RXFSFetchStatus_vnode, |
426 | 16, (21 + 3 + 6) * 4); | |
d2ddc776 DH |
427 | if (!call) { |
428 | fc->ac.error = -ENOMEM; | |
08e0e7c8 | 429 | return -ENOMEM; |
d2ddc776 | 430 | } |
1da177e4 | 431 | |
d2ddc776 | 432 | call->key = fc->key; |
97e3043a DH |
433 | call->reply[0] = vnode; |
434 | call->reply[1] = volsync; | |
0c3a5ac2 | 435 | call->expected_version = new_inode ? 1 : vnode->status.data_version; |
1da177e4 LT |
436 | |
437 | /* marshall the parameters */ | |
08e0e7c8 | 438 | bp = call->request; |
1da177e4 LT |
439 | bp[0] = htonl(FSFETCHSTATUS); |
440 | bp[1] = htonl(vnode->fid.vid); | |
441 | bp[2] = htonl(vnode->fid.vnode); | |
442 | bp[3] = htonl(vnode->fid.unique); | |
443 | ||
d2ddc776 DH |
444 | call->cb_break = fc->cb_break; |
445 | afs_use_fs_server(call, fc->cbi); | |
025db80c | 446 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 447 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
ec26815a | 448 | } |
1da177e4 | 449 | |
1da177e4 | 450 | /* |
08e0e7c8 | 451 | * deliver reply data to an FS.FetchData |
1da177e4 | 452 | */ |
d001648e | 453 | static int afs_deliver_fs_fetch_data(struct afs_call *call) |
1da177e4 | 454 | { |
97e3043a DH |
455 | struct afs_vnode *vnode = call->reply[0]; |
456 | struct afs_read *req = call->reply[2]; | |
08e0e7c8 | 457 | const __be32 *bp; |
196ee9cd | 458 | unsigned int size; |
08e0e7c8 | 459 | void *buffer; |
1da177e4 | 460 | int ret; |
1da177e4 | 461 | |
6a0e3999 | 462 | _enter("{%u,%zu/%u;%llu/%llu}", |
196ee9cd DH |
463 | call->unmarshall, call->offset, call->count, |
464 | req->remain, req->actual_len); | |
08e0e7c8 DH |
465 | |
466 | switch (call->unmarshall) { | |
467 | case 0: | |
196ee9cd | 468 | req->actual_len = 0; |
08e0e7c8 DH |
469 | call->offset = 0; |
470 | call->unmarshall++; | |
b9b1f8d5 DH |
471 | if (call->operation_ID != FSFETCHDATA64) { |
472 | call->unmarshall++; | |
473 | goto no_msw; | |
474 | } | |
08e0e7c8 | 475 | |
b9b1f8d5 DH |
476 | /* extract the upper part of the returned data length of an |
477 | * FSFETCHDATA64 op (which should always be 0 using this | |
478 | * client) */ | |
08e0e7c8 | 479 | case 1: |
b9b1f8d5 | 480 | _debug("extract data length (MSW)"); |
d001648e | 481 | ret = afs_extract_data(call, &call->tmp, 4, true); |
372ee163 DH |
482 | if (ret < 0) |
483 | return ret; | |
b9b1f8d5 | 484 | |
196ee9cd DH |
485 | req->actual_len = ntohl(call->tmp); |
486 | req->actual_len <<= 32; | |
b9b1f8d5 DH |
487 | call->offset = 0; |
488 | call->unmarshall++; | |
489 | ||
490 | no_msw: | |
491 | /* extract the returned data length */ | |
492 | case 2: | |
08e0e7c8 | 493 | _debug("extract data length"); |
d001648e | 494 | ret = afs_extract_data(call, &call->tmp, 4, true); |
372ee163 DH |
495 | if (ret < 0) |
496 | return ret; | |
1da177e4 | 497 | |
196ee9cd DH |
498 | req->actual_len |= ntohl(call->tmp); |
499 | _debug("DATA length: %llu", req->actual_len); | |
196ee9cd DH |
500 | |
501 | req->remain = req->actual_len; | |
502 | call->offset = req->pos & (PAGE_SIZE - 1); | |
503 | req->index = 0; | |
504 | if (req->actual_len == 0) | |
505 | goto no_more_data; | |
08e0e7c8 DH |
506 | call->unmarshall++; |
507 | ||
196ee9cd | 508 | begin_page: |
6db3ac3c | 509 | ASSERTCMP(req->index, <, req->nr_pages); |
196ee9cd DH |
510 | if (req->remain > PAGE_SIZE - call->offset) |
511 | size = PAGE_SIZE - call->offset; | |
512 | else | |
513 | size = req->remain; | |
514 | call->count = call->offset + size; | |
515 | ASSERTCMP(call->count, <=, PAGE_SIZE); | |
516 | req->remain -= size; | |
517 | ||
08e0e7c8 | 518 | /* extract the returned data */ |
b9b1f8d5 | 519 | case 3: |
6a0e3999 | 520 | _debug("extract data %llu/%llu %zu/%u", |
196ee9cd DH |
521 | req->remain, req->actual_len, call->offset, call->count); |
522 | ||
523 | buffer = kmap(req->pages[req->index]); | |
524 | ret = afs_extract_data(call, buffer, call->count, true); | |
525 | kunmap(req->pages[req->index]); | |
526 | if (ret < 0) | |
527 | return ret; | |
528 | if (call->offset == PAGE_SIZE) { | |
529 | if (req->page_done) | |
530 | req->page_done(call, req); | |
29f06985 | 531 | req->index++; |
196ee9cd | 532 | if (req->remain > 0) { |
196ee9cd | 533 | call->offset = 0; |
e8e581a8 DH |
534 | if (req->index >= req->nr_pages) { |
535 | call->unmarshall = 4; | |
6db3ac3c | 536 | goto begin_discard; |
e8e581a8 | 537 | } |
196ee9cd DH |
538 | goto begin_page; |
539 | } | |
08e0e7c8 | 540 | } |
6db3ac3c DH |
541 | goto no_more_data; |
542 | ||
543 | /* Discard any excess data the server gave us */ | |
544 | begin_discard: | |
545 | case 4: | |
6a0e3999 | 546 | size = min_t(loff_t, sizeof(afs_discard_buffer), req->remain); |
6db3ac3c | 547 | call->count = size; |
6a0e3999 | 548 | _debug("extract discard %llu/%llu %zu/%u", |
6db3ac3c DH |
549 | req->remain, req->actual_len, call->offset, call->count); |
550 | ||
551 | call->offset = 0; | |
552 | ret = afs_extract_data(call, afs_discard_buffer, call->count, true); | |
553 | req->remain -= call->offset; | |
554 | if (ret < 0) | |
555 | return ret; | |
556 | if (req->remain > 0) | |
557 | goto begin_discard; | |
1da177e4 | 558 | |
196ee9cd | 559 | no_more_data: |
08e0e7c8 | 560 | call->offset = 0; |
6db3ac3c | 561 | call->unmarshall = 5; |
1da177e4 | 562 | |
08e0e7c8 | 563 | /* extract the metadata */ |
6db3ac3c | 564 | case 5: |
d001648e DH |
565 | ret = afs_extract_data(call, call->buffer, |
566 | (21 + 3 + 6) * 4, false); | |
372ee163 DH |
567 | if (ret < 0) |
568 | return ret; | |
08e0e7c8 DH |
569 | |
570 | bp = call->buffer; | |
5f702c8e | 571 | if (xdr_decode_AFSFetchStatus(call, &bp, &vnode->status, vnode, |
f3ddee8d | 572 | &vnode->status.data_version, req) < 0) |
5f702c8e | 573 | return afs_protocol_error(call, -EBADMSG); |
c435ee34 | 574 | xdr_decode_AFSCallBack(call, vnode, &bp); |
97e3043a DH |
575 | if (call->reply[1]) |
576 | xdr_decode_AFSVolSync(&bp, call->reply[1]); | |
08e0e7c8 DH |
577 | |
578 | call->offset = 0; | |
579 | call->unmarshall++; | |
1da177e4 | 580 | |
6db3ac3c | 581 | case 6: |
08e0e7c8 | 582 | break; |
1da177e4 LT |
583 | } |
584 | ||
6db3ac3c DH |
585 | for (; req->index < req->nr_pages; req->index++) { |
586 | if (call->count < PAGE_SIZE) | |
587 | zero_user_segment(req->pages[req->index], | |
588 | call->count, PAGE_SIZE); | |
196ee9cd DH |
589 | if (req->page_done) |
590 | req->page_done(call, req); | |
6db3ac3c | 591 | call->count = 0; |
416351f2 DH |
592 | } |
593 | ||
08e0e7c8 DH |
594 | _leave(" = 0 [done]"); |
595 | return 0; | |
ec26815a | 596 | } |
1da177e4 | 597 | |
196ee9cd DH |
598 | static void afs_fetch_data_destructor(struct afs_call *call) |
599 | { | |
97e3043a | 600 | struct afs_read *req = call->reply[2]; |
196ee9cd DH |
601 | |
602 | afs_put_read(req); | |
603 | afs_flat_call_destructor(call); | |
604 | } | |
605 | ||
1da177e4 | 606 | /* |
08e0e7c8 | 607 | * FS.FetchData operation type |
1da177e4 | 608 | */ |
08e0e7c8 | 609 | static const struct afs_call_type afs_RXFSFetchData = { |
00d3b7a4 | 610 | .name = "FS.FetchData", |
025db80c | 611 | .op = afs_FS_FetchData, |
08e0e7c8 | 612 | .deliver = afs_deliver_fs_fetch_data, |
196ee9cd | 613 | .destructor = afs_fetch_data_destructor, |
08e0e7c8 DH |
614 | }; |
615 | ||
b9b1f8d5 DH |
616 | static const struct afs_call_type afs_RXFSFetchData64 = { |
617 | .name = "FS.FetchData64", | |
025db80c | 618 | .op = afs_FS_FetchData64, |
b9b1f8d5 | 619 | .deliver = afs_deliver_fs_fetch_data, |
196ee9cd | 620 | .destructor = afs_fetch_data_destructor, |
b9b1f8d5 DH |
621 | }; |
622 | ||
623 | /* | |
624 | * fetch data from a very large file | |
625 | */ | |
d2ddc776 | 626 | static int afs_fs_fetch_data64(struct afs_fs_cursor *fc, struct afs_read *req) |
b9b1f8d5 | 627 | { |
d2ddc776 | 628 | struct afs_vnode *vnode = fc->vnode; |
b9b1f8d5 | 629 | struct afs_call *call; |
f044c884 | 630 | struct afs_net *net = afs_v2net(vnode); |
b9b1f8d5 DH |
631 | __be32 *bp; |
632 | ||
633 | _enter(""); | |
634 | ||
f044c884 | 635 | call = afs_alloc_flat_call(net, &afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4); |
b9b1f8d5 DH |
636 | if (!call) |
637 | return -ENOMEM; | |
638 | ||
d2ddc776 | 639 | call->key = fc->key; |
97e3043a DH |
640 | call->reply[0] = vnode; |
641 | call->reply[1] = NULL; /* volsync */ | |
642 | call->reply[2] = req; | |
0c3a5ac2 | 643 | call->expected_version = vnode->status.data_version; |
b9b1f8d5 DH |
644 | |
645 | /* marshall the parameters */ | |
646 | bp = call->request; | |
647 | bp[0] = htonl(FSFETCHDATA64); | |
648 | bp[1] = htonl(vnode->fid.vid); | |
649 | bp[2] = htonl(vnode->fid.vnode); | |
650 | bp[3] = htonl(vnode->fid.unique); | |
196ee9cd DH |
651 | bp[4] = htonl(upper_32_bits(req->pos)); |
652 | bp[5] = htonl(lower_32_bits(req->pos)); | |
b9b1f8d5 | 653 | bp[6] = 0; |
196ee9cd | 654 | bp[7] = htonl(lower_32_bits(req->len)); |
b9b1f8d5 | 655 | |
f3ddee8d | 656 | refcount_inc(&req->usage); |
d2ddc776 DH |
657 | call->cb_break = fc->cb_break; |
658 | afs_use_fs_server(call, fc->cbi); | |
025db80c | 659 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 660 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
b9b1f8d5 DH |
661 | } |
662 | ||
08e0e7c8 DH |
663 | /* |
664 | * fetch data from a file | |
665 | */ | |
d2ddc776 | 666 | int afs_fs_fetch_data(struct afs_fs_cursor *fc, struct afs_read *req) |
1da177e4 | 667 | { |
d2ddc776 | 668 | struct afs_vnode *vnode = fc->vnode; |
08e0e7c8 | 669 | struct afs_call *call; |
f044c884 | 670 | struct afs_net *net = afs_v2net(vnode); |
1da177e4 LT |
671 | __be32 *bp; |
672 | ||
196ee9cd DH |
673 | if (upper_32_bits(req->pos) || |
674 | upper_32_bits(req->len) || | |
675 | upper_32_bits(req->pos + req->len)) | |
d2ddc776 | 676 | return afs_fs_fetch_data64(fc, req); |
b9b1f8d5 | 677 | |
08e0e7c8 | 678 | _enter(""); |
1da177e4 | 679 | |
f044c884 | 680 | call = afs_alloc_flat_call(net, &afs_RXFSFetchData, 24, (21 + 3 + 6) * 4); |
08e0e7c8 DH |
681 | if (!call) |
682 | return -ENOMEM; | |
1da177e4 | 683 | |
d2ddc776 | 684 | call->key = fc->key; |
97e3043a DH |
685 | call->reply[0] = vnode; |
686 | call->reply[1] = NULL; /* volsync */ | |
687 | call->reply[2] = req; | |
0c3a5ac2 | 688 | call->expected_version = vnode->status.data_version; |
1da177e4 LT |
689 | |
690 | /* marshall the parameters */ | |
08e0e7c8 DH |
691 | bp = call->request; |
692 | bp[0] = htonl(FSFETCHDATA); | |
693 | bp[1] = htonl(vnode->fid.vid); | |
694 | bp[2] = htonl(vnode->fid.vnode); | |
695 | bp[3] = htonl(vnode->fid.unique); | |
196ee9cd DH |
696 | bp[4] = htonl(lower_32_bits(req->pos)); |
697 | bp[5] = htonl(lower_32_bits(req->len)); | |
1da177e4 | 698 | |
f3ddee8d | 699 | refcount_inc(&req->usage); |
d2ddc776 DH |
700 | call->cb_break = fc->cb_break; |
701 | afs_use_fs_server(call, fc->cbi); | |
025db80c | 702 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 703 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
ec26815a | 704 | } |
260a9803 DH |
705 | |
706 | /* | |
707 | * deliver reply data to an FS.CreateFile or an FS.MakeDir | |
708 | */ | |
d001648e | 709 | static int afs_deliver_fs_create_vnode(struct afs_call *call) |
260a9803 | 710 | { |
97e3043a | 711 | struct afs_vnode *vnode = call->reply[0]; |
260a9803 | 712 | const __be32 *bp; |
372ee163 | 713 | int ret; |
260a9803 | 714 | |
d001648e | 715 | _enter("{%u}", call->unmarshall); |
260a9803 | 716 | |
d001648e | 717 | ret = afs_transfer_reply(call); |
372ee163 DH |
718 | if (ret < 0) |
719 | return ret; | |
260a9803 DH |
720 | |
721 | /* unmarshall the reply once we've received all of it */ | |
722 | bp = call->buffer; | |
97e3043a | 723 | xdr_decode_AFSFid(&bp, call->reply[1]); |
5f702c8e DH |
724 | if (xdr_decode_AFSFetchStatus(call, &bp, call->reply[2], NULL, NULL, NULL) < 0 || |
725 | xdr_decode_AFSFetchStatus(call, &bp, &vnode->status, vnode, | |
dd9fbcb8 | 726 | &call->expected_version, NULL) < 0) |
5f702c8e | 727 | return afs_protocol_error(call, -EBADMSG); |
97e3043a DH |
728 | xdr_decode_AFSCallBack_raw(&bp, call->reply[3]); |
729 | /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */ | |
260a9803 DH |
730 | |
731 | _leave(" = 0 [done]"); | |
732 | return 0; | |
733 | } | |
734 | ||
735 | /* | |
736 | * FS.CreateFile and FS.MakeDir operation type | |
737 | */ | |
025db80c DH |
738 | static const struct afs_call_type afs_RXFSCreateFile = { |
739 | .name = "FS.CreateFile", | |
740 | .op = afs_FS_CreateFile, | |
741 | .deliver = afs_deliver_fs_create_vnode, | |
742 | .destructor = afs_flat_call_destructor, | |
743 | }; | |
744 | ||
745 | static const struct afs_call_type afs_RXFSMakeDir = { | |
746 | .name = "FS.MakeDir", | |
747 | .op = afs_FS_MakeDir, | |
260a9803 | 748 | .deliver = afs_deliver_fs_create_vnode, |
260a9803 DH |
749 | .destructor = afs_flat_call_destructor, |
750 | }; | |
751 | ||
752 | /* | |
753 | * create a file or make a directory | |
754 | */ | |
8b2a464c | 755 | int afs_fs_create(struct afs_fs_cursor *fc, |
260a9803 DH |
756 | const char *name, |
757 | umode_t mode, | |
63a4681f | 758 | u64 current_data_version, |
260a9803 DH |
759 | struct afs_fid *newfid, |
760 | struct afs_file_status *newstatus, | |
d2ddc776 | 761 | struct afs_callback *newcb) |
260a9803 | 762 | { |
d2ddc776 | 763 | struct afs_vnode *vnode = fc->vnode; |
260a9803 | 764 | struct afs_call *call; |
f044c884 | 765 | struct afs_net *net = afs_v2net(vnode); |
260a9803 DH |
766 | size_t namesz, reqsz, padsz; |
767 | __be32 *bp; | |
768 | ||
769 | _enter(""); | |
770 | ||
771 | namesz = strlen(name); | |
772 | padsz = (4 - (namesz & 3)) & 3; | |
773 | reqsz = (5 * 4) + namesz + padsz + (6 * 4); | |
774 | ||
025db80c DH |
775 | call = afs_alloc_flat_call( |
776 | net, S_ISDIR(mode) ? &afs_RXFSMakeDir : &afs_RXFSCreateFile, | |
777 | reqsz, (3 + 21 + 21 + 3 + 6) * 4); | |
260a9803 DH |
778 | if (!call) |
779 | return -ENOMEM; | |
780 | ||
d2ddc776 | 781 | call->key = fc->key; |
97e3043a DH |
782 | call->reply[0] = vnode; |
783 | call->reply[1] = newfid; | |
784 | call->reply[2] = newstatus; | |
785 | call->reply[3] = newcb; | |
63a4681f | 786 | call->expected_version = current_data_version + 1; |
260a9803 DH |
787 | |
788 | /* marshall the parameters */ | |
789 | bp = call->request; | |
790 | *bp++ = htonl(S_ISDIR(mode) ? FSMAKEDIR : FSCREATEFILE); | |
791 | *bp++ = htonl(vnode->fid.vid); | |
792 | *bp++ = htonl(vnode->fid.vnode); | |
793 | *bp++ = htonl(vnode->fid.unique); | |
794 | *bp++ = htonl(namesz); | |
795 | memcpy(bp, name, namesz); | |
796 | bp = (void *) bp + namesz; | |
797 | if (padsz > 0) { | |
798 | memset(bp, 0, padsz); | |
799 | bp = (void *) bp + padsz; | |
800 | } | |
ab94f5d0 MD |
801 | *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME); |
802 | *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */ | |
260a9803 DH |
803 | *bp++ = 0; /* owner */ |
804 | *bp++ = 0; /* group */ | |
805 | *bp++ = htonl(mode & S_IALLUGO); /* unix mode */ | |
806 | *bp++ = 0; /* segment size */ | |
807 | ||
d2ddc776 | 808 | afs_use_fs_server(call, fc->cbi); |
025db80c | 809 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 810 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
260a9803 DH |
811 | } |
812 | ||
813 | /* | |
814 | * deliver reply data to an FS.RemoveFile or FS.RemoveDir | |
815 | */ | |
d001648e | 816 | static int afs_deliver_fs_remove(struct afs_call *call) |
260a9803 | 817 | { |
97e3043a | 818 | struct afs_vnode *vnode = call->reply[0]; |
260a9803 | 819 | const __be32 *bp; |
372ee163 | 820 | int ret; |
260a9803 | 821 | |
d001648e | 822 | _enter("{%u}", call->unmarshall); |
260a9803 | 823 | |
d001648e | 824 | ret = afs_transfer_reply(call); |
372ee163 DH |
825 | if (ret < 0) |
826 | return ret; | |
260a9803 DH |
827 | |
828 | /* unmarshall the reply once we've received all of it */ | |
829 | bp = call->buffer; | |
5f702c8e | 830 | if (xdr_decode_AFSFetchStatus(call, &bp, &vnode->status, vnode, |
dd9fbcb8 | 831 | &call->expected_version, NULL) < 0) |
5f702c8e | 832 | return afs_protocol_error(call, -EBADMSG); |
97e3043a | 833 | /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */ |
260a9803 DH |
834 | |
835 | _leave(" = 0 [done]"); | |
836 | return 0; | |
837 | } | |
838 | ||
839 | /* | |
840 | * FS.RemoveDir/FS.RemoveFile operation type | |
841 | */ | |
025db80c DH |
842 | static const struct afs_call_type afs_RXFSRemoveFile = { |
843 | .name = "FS.RemoveFile", | |
844 | .op = afs_FS_RemoveFile, | |
845 | .deliver = afs_deliver_fs_remove, | |
846 | .destructor = afs_flat_call_destructor, | |
847 | }; | |
848 | ||
849 | static const struct afs_call_type afs_RXFSRemoveDir = { | |
850 | .name = "FS.RemoveDir", | |
851 | .op = afs_FS_RemoveDir, | |
260a9803 | 852 | .deliver = afs_deliver_fs_remove, |
260a9803 DH |
853 | .destructor = afs_flat_call_destructor, |
854 | }; | |
855 | ||
856 | /* | |
857 | * remove a file or directory | |
858 | */ | |
63a4681f DH |
859 | int afs_fs_remove(struct afs_fs_cursor *fc, const char *name, bool isdir, |
860 | u64 current_data_version) | |
260a9803 | 861 | { |
d2ddc776 | 862 | struct afs_vnode *vnode = fc->vnode; |
260a9803 | 863 | struct afs_call *call; |
f044c884 | 864 | struct afs_net *net = afs_v2net(vnode); |
260a9803 DH |
865 | size_t namesz, reqsz, padsz; |
866 | __be32 *bp; | |
867 | ||
868 | _enter(""); | |
869 | ||
870 | namesz = strlen(name); | |
871 | padsz = (4 - (namesz & 3)) & 3; | |
872 | reqsz = (5 * 4) + namesz + padsz; | |
873 | ||
025db80c DH |
874 | call = afs_alloc_flat_call( |
875 | net, isdir ? &afs_RXFSRemoveDir : &afs_RXFSRemoveFile, | |
876 | reqsz, (21 + 6) * 4); | |
260a9803 DH |
877 | if (!call) |
878 | return -ENOMEM; | |
879 | ||
d2ddc776 | 880 | call->key = fc->key; |
97e3043a | 881 | call->reply[0] = vnode; |
63a4681f | 882 | call->expected_version = current_data_version + 1; |
260a9803 DH |
883 | |
884 | /* marshall the parameters */ | |
885 | bp = call->request; | |
886 | *bp++ = htonl(isdir ? FSREMOVEDIR : FSREMOVEFILE); | |
887 | *bp++ = htonl(vnode->fid.vid); | |
888 | *bp++ = htonl(vnode->fid.vnode); | |
889 | *bp++ = htonl(vnode->fid.unique); | |
890 | *bp++ = htonl(namesz); | |
891 | memcpy(bp, name, namesz); | |
892 | bp = (void *) bp + namesz; | |
893 | if (padsz > 0) { | |
894 | memset(bp, 0, padsz); | |
895 | bp = (void *) bp + padsz; | |
896 | } | |
897 | ||
d2ddc776 | 898 | afs_use_fs_server(call, fc->cbi); |
025db80c | 899 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 900 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
260a9803 DH |
901 | } |
902 | ||
903 | /* | |
904 | * deliver reply data to an FS.Link | |
905 | */ | |
d001648e | 906 | static int afs_deliver_fs_link(struct afs_call *call) |
260a9803 | 907 | { |
97e3043a | 908 | struct afs_vnode *dvnode = call->reply[0], *vnode = call->reply[1]; |
260a9803 | 909 | const __be32 *bp; |
372ee163 | 910 | int ret; |
260a9803 | 911 | |
d001648e | 912 | _enter("{%u}", call->unmarshall); |
260a9803 | 913 | |
d001648e | 914 | ret = afs_transfer_reply(call); |
372ee163 DH |
915 | if (ret < 0) |
916 | return ret; | |
260a9803 DH |
917 | |
918 | /* unmarshall the reply once we've received all of it */ | |
919 | bp = call->buffer; | |
5f702c8e DH |
920 | if (xdr_decode_AFSFetchStatus(call, &bp, &vnode->status, vnode, NULL, NULL) < 0 || |
921 | xdr_decode_AFSFetchStatus(call, &bp, &dvnode->status, dvnode, | |
dd9fbcb8 | 922 | &call->expected_version, NULL) < 0) |
5f702c8e | 923 | return afs_protocol_error(call, -EBADMSG); |
97e3043a | 924 | /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */ |
260a9803 DH |
925 | |
926 | _leave(" = 0 [done]"); | |
927 | return 0; | |
928 | } | |
929 | ||
930 | /* | |
931 | * FS.Link operation type | |
932 | */ | |
933 | static const struct afs_call_type afs_RXFSLink = { | |
934 | .name = "FS.Link", | |
025db80c | 935 | .op = afs_FS_Link, |
260a9803 | 936 | .deliver = afs_deliver_fs_link, |
260a9803 DH |
937 | .destructor = afs_flat_call_destructor, |
938 | }; | |
939 | ||
940 | /* | |
941 | * make a hard link | |
942 | */ | |
d2ddc776 | 943 | int afs_fs_link(struct afs_fs_cursor *fc, struct afs_vnode *vnode, |
63a4681f | 944 | const char *name, u64 current_data_version) |
260a9803 | 945 | { |
d2ddc776 | 946 | struct afs_vnode *dvnode = fc->vnode; |
260a9803 | 947 | struct afs_call *call; |
f044c884 | 948 | struct afs_net *net = afs_v2net(vnode); |
260a9803 DH |
949 | size_t namesz, reqsz, padsz; |
950 | __be32 *bp; | |
951 | ||
952 | _enter(""); | |
953 | ||
954 | namesz = strlen(name); | |
955 | padsz = (4 - (namesz & 3)) & 3; | |
956 | reqsz = (5 * 4) + namesz + padsz + (3 * 4); | |
957 | ||
f044c884 | 958 | call = afs_alloc_flat_call(net, &afs_RXFSLink, reqsz, (21 + 21 + 6) * 4); |
260a9803 DH |
959 | if (!call) |
960 | return -ENOMEM; | |
961 | ||
d2ddc776 | 962 | call->key = fc->key; |
97e3043a DH |
963 | call->reply[0] = dvnode; |
964 | call->reply[1] = vnode; | |
63a4681f | 965 | call->expected_version = current_data_version + 1; |
260a9803 DH |
966 | |
967 | /* marshall the parameters */ | |
968 | bp = call->request; | |
969 | *bp++ = htonl(FSLINK); | |
970 | *bp++ = htonl(dvnode->fid.vid); | |
971 | *bp++ = htonl(dvnode->fid.vnode); | |
972 | *bp++ = htonl(dvnode->fid.unique); | |
973 | *bp++ = htonl(namesz); | |
974 | memcpy(bp, name, namesz); | |
975 | bp = (void *) bp + namesz; | |
976 | if (padsz > 0) { | |
977 | memset(bp, 0, padsz); | |
978 | bp = (void *) bp + padsz; | |
979 | } | |
980 | *bp++ = htonl(vnode->fid.vid); | |
981 | *bp++ = htonl(vnode->fid.vnode); | |
982 | *bp++ = htonl(vnode->fid.unique); | |
983 | ||
d2ddc776 | 984 | afs_use_fs_server(call, fc->cbi); |
025db80c | 985 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 986 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
260a9803 DH |
987 | } |
988 | ||
989 | /* | |
990 | * deliver reply data to an FS.Symlink | |
991 | */ | |
d001648e | 992 | static int afs_deliver_fs_symlink(struct afs_call *call) |
260a9803 | 993 | { |
97e3043a | 994 | struct afs_vnode *vnode = call->reply[0]; |
260a9803 | 995 | const __be32 *bp; |
372ee163 | 996 | int ret; |
260a9803 | 997 | |
d001648e | 998 | _enter("{%u}", call->unmarshall); |
260a9803 | 999 | |
d001648e | 1000 | ret = afs_transfer_reply(call); |
372ee163 DH |
1001 | if (ret < 0) |
1002 | return ret; | |
260a9803 DH |
1003 | |
1004 | /* unmarshall the reply once we've received all of it */ | |
1005 | bp = call->buffer; | |
97e3043a | 1006 | xdr_decode_AFSFid(&bp, call->reply[1]); |
5f702c8e DH |
1007 | if (xdr_decode_AFSFetchStatus(call, &bp, call->reply[2], NULL, NULL, NULL) || |
1008 | xdr_decode_AFSFetchStatus(call, &bp, &vnode->status, vnode, | |
dd9fbcb8 | 1009 | &call->expected_version, NULL) < 0) |
5f702c8e | 1010 | return afs_protocol_error(call, -EBADMSG); |
97e3043a | 1011 | /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */ |
260a9803 DH |
1012 | |
1013 | _leave(" = 0 [done]"); | |
1014 | return 0; | |
1015 | } | |
1016 | ||
1017 | /* | |
1018 | * FS.Symlink operation type | |
1019 | */ | |
1020 | static const struct afs_call_type afs_RXFSSymlink = { | |
1021 | .name = "FS.Symlink", | |
025db80c | 1022 | .op = afs_FS_Symlink, |
260a9803 | 1023 | .deliver = afs_deliver_fs_symlink, |
260a9803 DH |
1024 | .destructor = afs_flat_call_destructor, |
1025 | }; | |
1026 | ||
1027 | /* | |
1028 | * create a symbolic link | |
1029 | */ | |
8b2a464c | 1030 | int afs_fs_symlink(struct afs_fs_cursor *fc, |
260a9803 DH |
1031 | const char *name, |
1032 | const char *contents, | |
63a4681f | 1033 | u64 current_data_version, |
260a9803 | 1034 | struct afs_fid *newfid, |
d2ddc776 | 1035 | struct afs_file_status *newstatus) |
260a9803 | 1036 | { |
d2ddc776 | 1037 | struct afs_vnode *vnode = fc->vnode; |
260a9803 | 1038 | struct afs_call *call; |
f044c884 | 1039 | struct afs_net *net = afs_v2net(vnode); |
260a9803 DH |
1040 | size_t namesz, reqsz, padsz, c_namesz, c_padsz; |
1041 | __be32 *bp; | |
1042 | ||
1043 | _enter(""); | |
1044 | ||
1045 | namesz = strlen(name); | |
1046 | padsz = (4 - (namesz & 3)) & 3; | |
1047 | ||
1048 | c_namesz = strlen(contents); | |
1049 | c_padsz = (4 - (c_namesz & 3)) & 3; | |
1050 | ||
1051 | reqsz = (6 * 4) + namesz + padsz + c_namesz + c_padsz + (6 * 4); | |
1052 | ||
f044c884 | 1053 | call = afs_alloc_flat_call(net, &afs_RXFSSymlink, reqsz, |
260a9803 DH |
1054 | (3 + 21 + 21 + 6) * 4); |
1055 | if (!call) | |
1056 | return -ENOMEM; | |
1057 | ||
d2ddc776 | 1058 | call->key = fc->key; |
97e3043a DH |
1059 | call->reply[0] = vnode; |
1060 | call->reply[1] = newfid; | |
1061 | call->reply[2] = newstatus; | |
63a4681f | 1062 | call->expected_version = current_data_version + 1; |
260a9803 DH |
1063 | |
1064 | /* marshall the parameters */ | |
1065 | bp = call->request; | |
1066 | *bp++ = htonl(FSSYMLINK); | |
1067 | *bp++ = htonl(vnode->fid.vid); | |
1068 | *bp++ = htonl(vnode->fid.vnode); | |
1069 | *bp++ = htonl(vnode->fid.unique); | |
1070 | *bp++ = htonl(namesz); | |
1071 | memcpy(bp, name, namesz); | |
1072 | bp = (void *) bp + namesz; | |
1073 | if (padsz > 0) { | |
1074 | memset(bp, 0, padsz); | |
1075 | bp = (void *) bp + padsz; | |
1076 | } | |
1077 | *bp++ = htonl(c_namesz); | |
1078 | memcpy(bp, contents, c_namesz); | |
1079 | bp = (void *) bp + c_namesz; | |
1080 | if (c_padsz > 0) { | |
1081 | memset(bp, 0, c_padsz); | |
1082 | bp = (void *) bp + c_padsz; | |
1083 | } | |
ab94f5d0 MD |
1084 | *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME); |
1085 | *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */ | |
260a9803 DH |
1086 | *bp++ = 0; /* owner */ |
1087 | *bp++ = 0; /* group */ | |
1088 | *bp++ = htonl(S_IRWXUGO); /* unix mode */ | |
1089 | *bp++ = 0; /* segment size */ | |
1090 | ||
d2ddc776 | 1091 | afs_use_fs_server(call, fc->cbi); |
025db80c | 1092 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 1093 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
260a9803 DH |
1094 | } |
1095 | ||
1096 | /* | |
1097 | * deliver reply data to an FS.Rename | |
1098 | */ | |
d001648e | 1099 | static int afs_deliver_fs_rename(struct afs_call *call) |
260a9803 | 1100 | { |
97e3043a | 1101 | struct afs_vnode *orig_dvnode = call->reply[0], *new_dvnode = call->reply[1]; |
260a9803 | 1102 | const __be32 *bp; |
372ee163 | 1103 | int ret; |
260a9803 | 1104 | |
d001648e | 1105 | _enter("{%u}", call->unmarshall); |
260a9803 | 1106 | |
d001648e | 1107 | ret = afs_transfer_reply(call); |
372ee163 DH |
1108 | if (ret < 0) |
1109 | return ret; | |
260a9803 DH |
1110 | |
1111 | /* unmarshall the reply once we've received all of it */ | |
1112 | bp = call->buffer; | |
5f702c8e | 1113 | if (xdr_decode_AFSFetchStatus(call, &bp, &orig_dvnode->status, orig_dvnode, |
dd9fbcb8 | 1114 | &call->expected_version, NULL) < 0) |
5f702c8e | 1115 | return afs_protocol_error(call, -EBADMSG); |
dd9fbcb8 | 1116 | if (new_dvnode != orig_dvnode && |
5f702c8e | 1117 | xdr_decode_AFSFetchStatus(call, &bp, &new_dvnode->status, new_dvnode, |
dd9fbcb8 | 1118 | &call->expected_version_2, NULL) < 0) |
5f702c8e | 1119 | return afs_protocol_error(call, -EBADMSG); |
97e3043a | 1120 | /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */ |
260a9803 DH |
1121 | |
1122 | _leave(" = 0 [done]"); | |
1123 | return 0; | |
1124 | } | |
1125 | ||
1126 | /* | |
1127 | * FS.Rename operation type | |
1128 | */ | |
1129 | static const struct afs_call_type afs_RXFSRename = { | |
1130 | .name = "FS.Rename", | |
025db80c | 1131 | .op = afs_FS_Rename, |
260a9803 | 1132 | .deliver = afs_deliver_fs_rename, |
260a9803 DH |
1133 | .destructor = afs_flat_call_destructor, |
1134 | }; | |
1135 | ||
1136 | /* | |
1137 | * create a symbolic link | |
1138 | */ | |
8b2a464c | 1139 | int afs_fs_rename(struct afs_fs_cursor *fc, |
260a9803 DH |
1140 | const char *orig_name, |
1141 | struct afs_vnode *new_dvnode, | |
63a4681f DH |
1142 | const char *new_name, |
1143 | u64 current_orig_data_version, | |
1144 | u64 current_new_data_version) | |
260a9803 | 1145 | { |
d2ddc776 | 1146 | struct afs_vnode *orig_dvnode = fc->vnode; |
260a9803 | 1147 | struct afs_call *call; |
f044c884 | 1148 | struct afs_net *net = afs_v2net(orig_dvnode); |
260a9803 DH |
1149 | size_t reqsz, o_namesz, o_padsz, n_namesz, n_padsz; |
1150 | __be32 *bp; | |
1151 | ||
1152 | _enter(""); | |
1153 | ||
1154 | o_namesz = strlen(orig_name); | |
1155 | o_padsz = (4 - (o_namesz & 3)) & 3; | |
1156 | ||
1157 | n_namesz = strlen(new_name); | |
1158 | n_padsz = (4 - (n_namesz & 3)) & 3; | |
1159 | ||
1160 | reqsz = (4 * 4) + | |
1161 | 4 + o_namesz + o_padsz + | |
1162 | (3 * 4) + | |
1163 | 4 + n_namesz + n_padsz; | |
1164 | ||
f044c884 | 1165 | call = afs_alloc_flat_call(net, &afs_RXFSRename, reqsz, (21 + 21 + 6) * 4); |
260a9803 DH |
1166 | if (!call) |
1167 | return -ENOMEM; | |
1168 | ||
d2ddc776 | 1169 | call->key = fc->key; |
97e3043a DH |
1170 | call->reply[0] = orig_dvnode; |
1171 | call->reply[1] = new_dvnode; | |
63a4681f DH |
1172 | call->expected_version = current_orig_data_version + 1; |
1173 | call->expected_version_2 = current_new_data_version + 1; | |
260a9803 DH |
1174 | |
1175 | /* marshall the parameters */ | |
1176 | bp = call->request; | |
1177 | *bp++ = htonl(FSRENAME); | |
1178 | *bp++ = htonl(orig_dvnode->fid.vid); | |
1179 | *bp++ = htonl(orig_dvnode->fid.vnode); | |
1180 | *bp++ = htonl(orig_dvnode->fid.unique); | |
1181 | *bp++ = htonl(o_namesz); | |
1182 | memcpy(bp, orig_name, o_namesz); | |
1183 | bp = (void *) bp + o_namesz; | |
1184 | if (o_padsz > 0) { | |
1185 | memset(bp, 0, o_padsz); | |
1186 | bp = (void *) bp + o_padsz; | |
1187 | } | |
1188 | ||
1189 | *bp++ = htonl(new_dvnode->fid.vid); | |
1190 | *bp++ = htonl(new_dvnode->fid.vnode); | |
1191 | *bp++ = htonl(new_dvnode->fid.unique); | |
1192 | *bp++ = htonl(n_namesz); | |
1193 | memcpy(bp, new_name, n_namesz); | |
1194 | bp = (void *) bp + n_namesz; | |
1195 | if (n_padsz > 0) { | |
1196 | memset(bp, 0, n_padsz); | |
1197 | bp = (void *) bp + n_padsz; | |
1198 | } | |
1199 | ||
d2ddc776 | 1200 | afs_use_fs_server(call, fc->cbi); |
025db80c | 1201 | trace_afs_make_fs_call(call, &orig_dvnode->fid); |
d2ddc776 | 1202 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
260a9803 | 1203 | } |
31143d5d DH |
1204 | |
1205 | /* | |
1206 | * deliver reply data to an FS.StoreData | |
1207 | */ | |
d001648e | 1208 | static int afs_deliver_fs_store_data(struct afs_call *call) |
31143d5d | 1209 | { |
97e3043a | 1210 | struct afs_vnode *vnode = call->reply[0]; |
31143d5d | 1211 | const __be32 *bp; |
372ee163 | 1212 | int ret; |
31143d5d | 1213 | |
d001648e | 1214 | _enter(""); |
31143d5d | 1215 | |
d001648e | 1216 | ret = afs_transfer_reply(call); |
372ee163 DH |
1217 | if (ret < 0) |
1218 | return ret; | |
31143d5d DH |
1219 | |
1220 | /* unmarshall the reply once we've received all of it */ | |
1221 | bp = call->buffer; | |
5f702c8e | 1222 | if (xdr_decode_AFSFetchStatus(call, &bp, &vnode->status, vnode, |
dd9fbcb8 | 1223 | &call->expected_version, NULL) < 0) |
5f702c8e | 1224 | return afs_protocol_error(call, -EBADMSG); |
97e3043a | 1225 | /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */ |
31143d5d DH |
1226 | |
1227 | afs_pages_written_back(vnode, call); | |
1228 | ||
1229 | _leave(" = 0 [done]"); | |
1230 | return 0; | |
1231 | } | |
1232 | ||
1233 | /* | |
1234 | * FS.StoreData operation type | |
1235 | */ | |
1236 | static const struct afs_call_type afs_RXFSStoreData = { | |
1237 | .name = "FS.StoreData", | |
025db80c | 1238 | .op = afs_FS_StoreData, |
31143d5d | 1239 | .deliver = afs_deliver_fs_store_data, |
31143d5d DH |
1240 | .destructor = afs_flat_call_destructor, |
1241 | }; | |
1242 | ||
b9b1f8d5 DH |
1243 | static const struct afs_call_type afs_RXFSStoreData64 = { |
1244 | .name = "FS.StoreData64", | |
025db80c | 1245 | .op = afs_FS_StoreData64, |
b9b1f8d5 | 1246 | .deliver = afs_deliver_fs_store_data, |
b9b1f8d5 DH |
1247 | .destructor = afs_flat_call_destructor, |
1248 | }; | |
1249 | ||
1250 | /* | |
1251 | * store a set of pages to a very large file | |
1252 | */ | |
8b2a464c | 1253 | static int afs_fs_store_data64(struct afs_fs_cursor *fc, |
4343d008 | 1254 | struct address_space *mapping, |
b9b1f8d5 DH |
1255 | pgoff_t first, pgoff_t last, |
1256 | unsigned offset, unsigned to, | |
d2ddc776 | 1257 | loff_t size, loff_t pos, loff_t i_size) |
b9b1f8d5 | 1258 | { |
4343d008 | 1259 | struct afs_vnode *vnode = fc->vnode; |
b9b1f8d5 | 1260 | struct afs_call *call; |
f044c884 | 1261 | struct afs_net *net = afs_v2net(vnode); |
b9b1f8d5 DH |
1262 | __be32 *bp; |
1263 | ||
1264 | _enter(",%x,{%x:%u},,", | |
4343d008 | 1265 | key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode); |
b9b1f8d5 | 1266 | |
f044c884 | 1267 | call = afs_alloc_flat_call(net, &afs_RXFSStoreData64, |
b9b1f8d5 DH |
1268 | (4 + 6 + 3 * 2) * 4, |
1269 | (21 + 6) * 4); | |
1270 | if (!call) | |
1271 | return -ENOMEM; | |
1272 | ||
4343d008 DH |
1273 | call->key = fc->key; |
1274 | call->mapping = mapping; | |
97e3043a | 1275 | call->reply[0] = vnode; |
b9b1f8d5 DH |
1276 | call->first = first; |
1277 | call->last = last; | |
1278 | call->first_offset = offset; | |
1279 | call->last_to = to; | |
1280 | call->send_pages = true; | |
0c3a5ac2 | 1281 | call->expected_version = vnode->status.data_version + 1; |
b9b1f8d5 DH |
1282 | |
1283 | /* marshall the parameters */ | |
1284 | bp = call->request; | |
1285 | *bp++ = htonl(FSSTOREDATA64); | |
1286 | *bp++ = htonl(vnode->fid.vid); | |
1287 | *bp++ = htonl(vnode->fid.vnode); | |
1288 | *bp++ = htonl(vnode->fid.unique); | |
1289 | ||
ab94f5d0 MD |
1290 | *bp++ = htonl(AFS_SET_MTIME); /* mask */ |
1291 | *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */ | |
b9b1f8d5 DH |
1292 | *bp++ = 0; /* owner */ |
1293 | *bp++ = 0; /* group */ | |
1294 | *bp++ = 0; /* unix mode */ | |
1295 | *bp++ = 0; /* segment size */ | |
1296 | ||
1297 | *bp++ = htonl(pos >> 32); | |
1298 | *bp++ = htonl((u32) pos); | |
1299 | *bp++ = htonl(size >> 32); | |
1300 | *bp++ = htonl((u32) size); | |
1301 | *bp++ = htonl(i_size >> 32); | |
1302 | *bp++ = htonl((u32) i_size); | |
1303 | ||
025db80c | 1304 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 1305 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
b9b1f8d5 DH |
1306 | } |
1307 | ||
31143d5d DH |
1308 | /* |
1309 | * store a set of pages | |
1310 | */ | |
4343d008 | 1311 | int afs_fs_store_data(struct afs_fs_cursor *fc, struct address_space *mapping, |
31143d5d | 1312 | pgoff_t first, pgoff_t last, |
d2ddc776 | 1313 | unsigned offset, unsigned to) |
31143d5d | 1314 | { |
4343d008 | 1315 | struct afs_vnode *vnode = fc->vnode; |
31143d5d | 1316 | struct afs_call *call; |
f044c884 | 1317 | struct afs_net *net = afs_v2net(vnode); |
31143d5d DH |
1318 | loff_t size, pos, i_size; |
1319 | __be32 *bp; | |
1320 | ||
1321 | _enter(",%x,{%x:%u},,", | |
4343d008 | 1322 | key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode); |
31143d5d | 1323 | |
146a1192 | 1324 | size = (loff_t)to - (loff_t)offset; |
31143d5d DH |
1325 | if (first != last) |
1326 | size += (loff_t)(last - first) << PAGE_SHIFT; | |
1327 | pos = (loff_t)first << PAGE_SHIFT; | |
1328 | pos += offset; | |
1329 | ||
1330 | i_size = i_size_read(&vnode->vfs_inode); | |
1331 | if (pos + size > i_size) | |
1332 | i_size = size + pos; | |
1333 | ||
1334 | _debug("size %llx, at %llx, i_size %llx", | |
1335 | (unsigned long long) size, (unsigned long long) pos, | |
1336 | (unsigned long long) i_size); | |
1337 | ||
b9b1f8d5 | 1338 | if (pos >> 32 || i_size >> 32 || size >> 32 || (pos + size) >> 32) |
4343d008 | 1339 | return afs_fs_store_data64(fc, mapping, first, last, offset, to, |
d2ddc776 | 1340 | size, pos, i_size); |
31143d5d | 1341 | |
f044c884 | 1342 | call = afs_alloc_flat_call(net, &afs_RXFSStoreData, |
31143d5d DH |
1343 | (4 + 6 + 3) * 4, |
1344 | (21 + 6) * 4); | |
1345 | if (!call) | |
1346 | return -ENOMEM; | |
1347 | ||
4343d008 DH |
1348 | call->key = fc->key; |
1349 | call->mapping = mapping; | |
97e3043a | 1350 | call->reply[0] = vnode; |
31143d5d DH |
1351 | call->first = first; |
1352 | call->last = last; | |
1353 | call->first_offset = offset; | |
1354 | call->last_to = to; | |
1355 | call->send_pages = true; | |
0c3a5ac2 | 1356 | call->expected_version = vnode->status.data_version + 1; |
31143d5d DH |
1357 | |
1358 | /* marshall the parameters */ | |
1359 | bp = call->request; | |
1360 | *bp++ = htonl(FSSTOREDATA); | |
1361 | *bp++ = htonl(vnode->fid.vid); | |
1362 | *bp++ = htonl(vnode->fid.vnode); | |
1363 | *bp++ = htonl(vnode->fid.unique); | |
1364 | ||
ab94f5d0 MD |
1365 | *bp++ = htonl(AFS_SET_MTIME); /* mask */ |
1366 | *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */ | |
31143d5d DH |
1367 | *bp++ = 0; /* owner */ |
1368 | *bp++ = 0; /* group */ | |
1369 | *bp++ = 0; /* unix mode */ | |
1370 | *bp++ = 0; /* segment size */ | |
1371 | ||
1372 | *bp++ = htonl(pos); | |
1373 | *bp++ = htonl(size); | |
1374 | *bp++ = htonl(i_size); | |
1375 | ||
d2ddc776 | 1376 | afs_use_fs_server(call, fc->cbi); |
025db80c | 1377 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 1378 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
31143d5d DH |
1379 | } |
1380 | ||
1381 | /* | |
1382 | * deliver reply data to an FS.StoreStatus | |
1383 | */ | |
d001648e | 1384 | static int afs_deliver_fs_store_status(struct afs_call *call) |
31143d5d | 1385 | { |
97e3043a | 1386 | struct afs_vnode *vnode = call->reply[0]; |
31143d5d | 1387 | const __be32 *bp; |
372ee163 | 1388 | int ret; |
31143d5d | 1389 | |
d001648e | 1390 | _enter(""); |
31143d5d | 1391 | |
d001648e | 1392 | ret = afs_transfer_reply(call); |
372ee163 DH |
1393 | if (ret < 0) |
1394 | return ret; | |
31143d5d DH |
1395 | |
1396 | /* unmarshall the reply once we've received all of it */ | |
31143d5d | 1397 | bp = call->buffer; |
5f702c8e | 1398 | if (xdr_decode_AFSFetchStatus(call, &bp, &vnode->status, vnode, |
dd9fbcb8 | 1399 | &call->expected_version, NULL) < 0) |
5f702c8e | 1400 | return afs_protocol_error(call, -EBADMSG); |
97e3043a | 1401 | /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */ |
31143d5d DH |
1402 | |
1403 | _leave(" = 0 [done]"); | |
1404 | return 0; | |
1405 | } | |
1406 | ||
1407 | /* | |
1408 | * FS.StoreStatus operation type | |
1409 | */ | |
1410 | static const struct afs_call_type afs_RXFSStoreStatus = { | |
1411 | .name = "FS.StoreStatus", | |
025db80c | 1412 | .op = afs_FS_StoreStatus, |
31143d5d | 1413 | .deliver = afs_deliver_fs_store_status, |
31143d5d DH |
1414 | .destructor = afs_flat_call_destructor, |
1415 | }; | |
1416 | ||
1417 | static const struct afs_call_type afs_RXFSStoreData_as_Status = { | |
1418 | .name = "FS.StoreData", | |
025db80c | 1419 | .op = afs_FS_StoreData, |
31143d5d | 1420 | .deliver = afs_deliver_fs_store_status, |
31143d5d DH |
1421 | .destructor = afs_flat_call_destructor, |
1422 | }; | |
1423 | ||
b9b1f8d5 DH |
1424 | static const struct afs_call_type afs_RXFSStoreData64_as_Status = { |
1425 | .name = "FS.StoreData64", | |
025db80c | 1426 | .op = afs_FS_StoreData64, |
b9b1f8d5 | 1427 | .deliver = afs_deliver_fs_store_status, |
b9b1f8d5 DH |
1428 | .destructor = afs_flat_call_destructor, |
1429 | }; | |
1430 | ||
1431 | /* | |
1432 | * set the attributes on a very large file, using FS.StoreData rather than | |
1433 | * FS.StoreStatus so as to alter the file size also | |
1434 | */ | |
d2ddc776 | 1435 | static int afs_fs_setattr_size64(struct afs_fs_cursor *fc, struct iattr *attr) |
b9b1f8d5 | 1436 | { |
d2ddc776 | 1437 | struct afs_vnode *vnode = fc->vnode; |
b9b1f8d5 | 1438 | struct afs_call *call; |
f044c884 | 1439 | struct afs_net *net = afs_v2net(vnode); |
b9b1f8d5 DH |
1440 | __be32 *bp; |
1441 | ||
1442 | _enter(",%x,{%x:%u},,", | |
d2ddc776 | 1443 | key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode); |
b9b1f8d5 DH |
1444 | |
1445 | ASSERT(attr->ia_valid & ATTR_SIZE); | |
1446 | ||
f044c884 | 1447 | call = afs_alloc_flat_call(net, &afs_RXFSStoreData64_as_Status, |
b9b1f8d5 DH |
1448 | (4 + 6 + 3 * 2) * 4, |
1449 | (21 + 6) * 4); | |
1450 | if (!call) | |
1451 | return -ENOMEM; | |
1452 | ||
d2ddc776 | 1453 | call->key = fc->key; |
97e3043a | 1454 | call->reply[0] = vnode; |
0c3a5ac2 | 1455 | call->expected_version = vnode->status.data_version + 1; |
b9b1f8d5 DH |
1456 | |
1457 | /* marshall the parameters */ | |
1458 | bp = call->request; | |
1459 | *bp++ = htonl(FSSTOREDATA64); | |
1460 | *bp++ = htonl(vnode->fid.vid); | |
1461 | *bp++ = htonl(vnode->fid.vnode); | |
1462 | *bp++ = htonl(vnode->fid.unique); | |
1463 | ||
1464 | xdr_encode_AFS_StoreStatus(&bp, attr); | |
1465 | ||
1466 | *bp++ = 0; /* position of start of write */ | |
1467 | *bp++ = 0; | |
1468 | *bp++ = 0; /* size of write */ | |
1469 | *bp++ = 0; | |
1470 | *bp++ = htonl(attr->ia_size >> 32); /* new file length */ | |
1471 | *bp++ = htonl((u32) attr->ia_size); | |
1472 | ||
d2ddc776 | 1473 | afs_use_fs_server(call, fc->cbi); |
025db80c | 1474 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 1475 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
b9b1f8d5 DH |
1476 | } |
1477 | ||
31143d5d DH |
1478 | /* |
1479 | * set the attributes on a file, using FS.StoreData rather than FS.StoreStatus | |
1480 | * so as to alter the file size also | |
1481 | */ | |
d2ddc776 | 1482 | static int afs_fs_setattr_size(struct afs_fs_cursor *fc, struct iattr *attr) |
31143d5d | 1483 | { |
d2ddc776 | 1484 | struct afs_vnode *vnode = fc->vnode; |
31143d5d | 1485 | struct afs_call *call; |
f044c884 | 1486 | struct afs_net *net = afs_v2net(vnode); |
31143d5d DH |
1487 | __be32 *bp; |
1488 | ||
1489 | _enter(",%x,{%x:%u},,", | |
d2ddc776 | 1490 | key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode); |
31143d5d DH |
1491 | |
1492 | ASSERT(attr->ia_valid & ATTR_SIZE); | |
b9b1f8d5 | 1493 | if (attr->ia_size >> 32) |
d2ddc776 | 1494 | return afs_fs_setattr_size64(fc, attr); |
31143d5d | 1495 | |
f044c884 | 1496 | call = afs_alloc_flat_call(net, &afs_RXFSStoreData_as_Status, |
31143d5d DH |
1497 | (4 + 6 + 3) * 4, |
1498 | (21 + 6) * 4); | |
1499 | if (!call) | |
1500 | return -ENOMEM; | |
1501 | ||
d2ddc776 | 1502 | call->key = fc->key; |
97e3043a | 1503 | call->reply[0] = vnode; |
0c3a5ac2 | 1504 | call->expected_version = vnode->status.data_version + 1; |
31143d5d DH |
1505 | |
1506 | /* marshall the parameters */ | |
1507 | bp = call->request; | |
1508 | *bp++ = htonl(FSSTOREDATA); | |
1509 | *bp++ = htonl(vnode->fid.vid); | |
1510 | *bp++ = htonl(vnode->fid.vnode); | |
1511 | *bp++ = htonl(vnode->fid.unique); | |
1512 | ||
1513 | xdr_encode_AFS_StoreStatus(&bp, attr); | |
1514 | ||
1515 | *bp++ = 0; /* position of start of write */ | |
1516 | *bp++ = 0; /* size of write */ | |
1517 | *bp++ = htonl(attr->ia_size); /* new file length */ | |
1518 | ||
d2ddc776 | 1519 | afs_use_fs_server(call, fc->cbi); |
025db80c | 1520 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 1521 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
31143d5d DH |
1522 | } |
1523 | ||
1524 | /* | |
1525 | * set the attributes on a file, using FS.StoreData if there's a change in file | |
1526 | * size, and FS.StoreStatus otherwise | |
1527 | */ | |
d2ddc776 | 1528 | int afs_fs_setattr(struct afs_fs_cursor *fc, struct iattr *attr) |
31143d5d | 1529 | { |
d2ddc776 | 1530 | struct afs_vnode *vnode = fc->vnode; |
31143d5d | 1531 | struct afs_call *call; |
f044c884 | 1532 | struct afs_net *net = afs_v2net(vnode); |
31143d5d DH |
1533 | __be32 *bp; |
1534 | ||
1535 | if (attr->ia_valid & ATTR_SIZE) | |
d2ddc776 | 1536 | return afs_fs_setattr_size(fc, attr); |
31143d5d DH |
1537 | |
1538 | _enter(",%x,{%x:%u},,", | |
d2ddc776 | 1539 | key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode); |
31143d5d | 1540 | |
f044c884 | 1541 | call = afs_alloc_flat_call(net, &afs_RXFSStoreStatus, |
31143d5d DH |
1542 | (4 + 6) * 4, |
1543 | (21 + 6) * 4); | |
1544 | if (!call) | |
1545 | return -ENOMEM; | |
1546 | ||
d2ddc776 | 1547 | call->key = fc->key; |
97e3043a | 1548 | call->reply[0] = vnode; |
0c3a5ac2 | 1549 | call->expected_version = vnode->status.data_version; |
31143d5d DH |
1550 | |
1551 | /* marshall the parameters */ | |
1552 | bp = call->request; | |
1553 | *bp++ = htonl(FSSTORESTATUS); | |
1554 | *bp++ = htonl(vnode->fid.vid); | |
1555 | *bp++ = htonl(vnode->fid.vnode); | |
1556 | *bp++ = htonl(vnode->fid.unique); | |
1557 | ||
1558 | xdr_encode_AFS_StoreStatus(&bp, attr); | |
1559 | ||
d2ddc776 | 1560 | afs_use_fs_server(call, fc->cbi); |
025db80c | 1561 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 1562 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
31143d5d | 1563 | } |
45222b9e DH |
1564 | |
1565 | /* | |
1566 | * deliver reply data to an FS.GetVolumeStatus | |
1567 | */ | |
d001648e | 1568 | static int afs_deliver_fs_get_volume_status(struct afs_call *call) |
45222b9e DH |
1569 | { |
1570 | const __be32 *bp; | |
1571 | char *p; | |
1572 | int ret; | |
1573 | ||
d001648e | 1574 | _enter("{%u}", call->unmarshall); |
45222b9e DH |
1575 | |
1576 | switch (call->unmarshall) { | |
1577 | case 0: | |
1578 | call->offset = 0; | |
1579 | call->unmarshall++; | |
1580 | ||
1581 | /* extract the returned status record */ | |
1582 | case 1: | |
1583 | _debug("extract status"); | |
d001648e DH |
1584 | ret = afs_extract_data(call, call->buffer, |
1585 | 12 * 4, true); | |
372ee163 DH |
1586 | if (ret < 0) |
1587 | return ret; | |
45222b9e DH |
1588 | |
1589 | bp = call->buffer; | |
97e3043a | 1590 | xdr_decode_AFSFetchVolumeStatus(&bp, call->reply[1]); |
45222b9e DH |
1591 | call->offset = 0; |
1592 | call->unmarshall++; | |
1593 | ||
1594 | /* extract the volume name length */ | |
1595 | case 2: | |
d001648e | 1596 | ret = afs_extract_data(call, &call->tmp, 4, true); |
372ee163 DH |
1597 | if (ret < 0) |
1598 | return ret; | |
45222b9e DH |
1599 | |
1600 | call->count = ntohl(call->tmp); | |
1601 | _debug("volname length: %u", call->count); | |
1602 | if (call->count >= AFSNAMEMAX) | |
5f702c8e | 1603 | return afs_protocol_error(call, -EBADMSG); |
45222b9e DH |
1604 | call->offset = 0; |
1605 | call->unmarshall++; | |
1606 | ||
1607 | /* extract the volume name */ | |
1608 | case 3: | |
1609 | _debug("extract volname"); | |
1610 | if (call->count > 0) { | |
97e3043a | 1611 | ret = afs_extract_data(call, call->reply[2], |
d001648e | 1612 | call->count, true); |
372ee163 DH |
1613 | if (ret < 0) |
1614 | return ret; | |
45222b9e DH |
1615 | } |
1616 | ||
97e3043a | 1617 | p = call->reply[2]; |
45222b9e DH |
1618 | p[call->count] = 0; |
1619 | _debug("volname '%s'", p); | |
1620 | ||
1621 | call->offset = 0; | |
1622 | call->unmarshall++; | |
1623 | ||
1624 | /* extract the volume name padding */ | |
1625 | if ((call->count & 3) == 0) { | |
1626 | call->unmarshall++; | |
1627 | goto no_volname_padding; | |
1628 | } | |
1629 | call->count = 4 - (call->count & 3); | |
1630 | ||
1631 | case 4: | |
d001648e DH |
1632 | ret = afs_extract_data(call, call->buffer, |
1633 | call->count, true); | |
372ee163 DH |
1634 | if (ret < 0) |
1635 | return ret; | |
45222b9e DH |
1636 | |
1637 | call->offset = 0; | |
1638 | call->unmarshall++; | |
1639 | no_volname_padding: | |
1640 | ||
1641 | /* extract the offline message length */ | |
1642 | case 5: | |
d001648e | 1643 | ret = afs_extract_data(call, &call->tmp, 4, true); |
372ee163 DH |
1644 | if (ret < 0) |
1645 | return ret; | |
45222b9e DH |
1646 | |
1647 | call->count = ntohl(call->tmp); | |
1648 | _debug("offline msg length: %u", call->count); | |
1649 | if (call->count >= AFSNAMEMAX) | |
5f702c8e | 1650 | return afs_protocol_error(call, -EBADMSG); |
45222b9e DH |
1651 | call->offset = 0; |
1652 | call->unmarshall++; | |
1653 | ||
1654 | /* extract the offline message */ | |
1655 | case 6: | |
1656 | _debug("extract offline"); | |
1657 | if (call->count > 0) { | |
97e3043a | 1658 | ret = afs_extract_data(call, call->reply[2], |
d001648e | 1659 | call->count, true); |
372ee163 DH |
1660 | if (ret < 0) |
1661 | return ret; | |
45222b9e DH |
1662 | } |
1663 | ||
97e3043a | 1664 | p = call->reply[2]; |
45222b9e DH |
1665 | p[call->count] = 0; |
1666 | _debug("offline '%s'", p); | |
1667 | ||
1668 | call->offset = 0; | |
1669 | call->unmarshall++; | |
1670 | ||
1671 | /* extract the offline message padding */ | |
1672 | if ((call->count & 3) == 0) { | |
1673 | call->unmarshall++; | |
1674 | goto no_offline_padding; | |
1675 | } | |
1676 | call->count = 4 - (call->count & 3); | |
1677 | ||
1678 | case 7: | |
d001648e DH |
1679 | ret = afs_extract_data(call, call->buffer, |
1680 | call->count, true); | |
372ee163 DH |
1681 | if (ret < 0) |
1682 | return ret; | |
45222b9e DH |
1683 | |
1684 | call->offset = 0; | |
1685 | call->unmarshall++; | |
1686 | no_offline_padding: | |
1687 | ||
1688 | /* extract the message of the day length */ | |
1689 | case 8: | |
d001648e | 1690 | ret = afs_extract_data(call, &call->tmp, 4, true); |
372ee163 DH |
1691 | if (ret < 0) |
1692 | return ret; | |
45222b9e DH |
1693 | |
1694 | call->count = ntohl(call->tmp); | |
1695 | _debug("motd length: %u", call->count); | |
1696 | if (call->count >= AFSNAMEMAX) | |
5f702c8e | 1697 | return afs_protocol_error(call, -EBADMSG); |
45222b9e DH |
1698 | call->offset = 0; |
1699 | call->unmarshall++; | |
1700 | ||
1701 | /* extract the message of the day */ | |
1702 | case 9: | |
1703 | _debug("extract motd"); | |
1704 | if (call->count > 0) { | |
97e3043a | 1705 | ret = afs_extract_data(call, call->reply[2], |
d001648e | 1706 | call->count, true); |
372ee163 DH |
1707 | if (ret < 0) |
1708 | return ret; | |
45222b9e DH |
1709 | } |
1710 | ||
97e3043a | 1711 | p = call->reply[2]; |
45222b9e DH |
1712 | p[call->count] = 0; |
1713 | _debug("motd '%s'", p); | |
1714 | ||
1715 | call->offset = 0; | |
1716 | call->unmarshall++; | |
1717 | ||
1718 | /* extract the message of the day padding */ | |
d001648e | 1719 | call->count = (4 - (call->count & 3)) & 3; |
45222b9e DH |
1720 | |
1721 | case 10: | |
d001648e DH |
1722 | ret = afs_extract_data(call, call->buffer, |
1723 | call->count, false); | |
372ee163 DH |
1724 | if (ret < 0) |
1725 | return ret; | |
45222b9e DH |
1726 | |
1727 | call->offset = 0; | |
1728 | call->unmarshall++; | |
45222b9e | 1729 | case 11: |
45222b9e DH |
1730 | break; |
1731 | } | |
1732 | ||
45222b9e DH |
1733 | _leave(" = 0 [done]"); |
1734 | return 0; | |
1735 | } | |
1736 | ||
1737 | /* | |
1738 | * destroy an FS.GetVolumeStatus call | |
1739 | */ | |
1740 | static void afs_get_volume_status_call_destructor(struct afs_call *call) | |
1741 | { | |
97e3043a DH |
1742 | kfree(call->reply[2]); |
1743 | call->reply[2] = NULL; | |
45222b9e DH |
1744 | afs_flat_call_destructor(call); |
1745 | } | |
1746 | ||
1747 | /* | |
1748 | * FS.GetVolumeStatus operation type | |
1749 | */ | |
1750 | static const struct afs_call_type afs_RXFSGetVolumeStatus = { | |
1751 | .name = "FS.GetVolumeStatus", | |
025db80c | 1752 | .op = afs_FS_GetVolumeStatus, |
45222b9e | 1753 | .deliver = afs_deliver_fs_get_volume_status, |
45222b9e DH |
1754 | .destructor = afs_get_volume_status_call_destructor, |
1755 | }; | |
1756 | ||
1757 | /* | |
1758 | * fetch the status of a volume | |
1759 | */ | |
8b2a464c | 1760 | int afs_fs_get_volume_status(struct afs_fs_cursor *fc, |
d2ddc776 | 1761 | struct afs_volume_status *vs) |
45222b9e | 1762 | { |
d2ddc776 | 1763 | struct afs_vnode *vnode = fc->vnode; |
45222b9e | 1764 | struct afs_call *call; |
f044c884 | 1765 | struct afs_net *net = afs_v2net(vnode); |
45222b9e DH |
1766 | __be32 *bp; |
1767 | void *tmpbuf; | |
1768 | ||
1769 | _enter(""); | |
1770 | ||
1771 | tmpbuf = kmalloc(AFSOPAQUEMAX, GFP_KERNEL); | |
1772 | if (!tmpbuf) | |
1773 | return -ENOMEM; | |
1774 | ||
f044c884 | 1775 | call = afs_alloc_flat_call(net, &afs_RXFSGetVolumeStatus, 2 * 4, 12 * 4); |
45222b9e DH |
1776 | if (!call) { |
1777 | kfree(tmpbuf); | |
1778 | return -ENOMEM; | |
1779 | } | |
1780 | ||
d2ddc776 | 1781 | call->key = fc->key; |
97e3043a DH |
1782 | call->reply[0] = vnode; |
1783 | call->reply[1] = vs; | |
1784 | call->reply[2] = tmpbuf; | |
45222b9e DH |
1785 | |
1786 | /* marshall the parameters */ | |
1787 | bp = call->request; | |
1788 | bp[0] = htonl(FSGETVOLUMESTATUS); | |
1789 | bp[1] = htonl(vnode->fid.vid); | |
1790 | ||
d2ddc776 | 1791 | afs_use_fs_server(call, fc->cbi); |
025db80c | 1792 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 1793 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
45222b9e | 1794 | } |
e8d6c554 DH |
1795 | |
1796 | /* | |
1797 | * deliver reply data to an FS.SetLock, FS.ExtendLock or FS.ReleaseLock | |
1798 | */ | |
d001648e | 1799 | static int afs_deliver_fs_xxxx_lock(struct afs_call *call) |
e8d6c554 DH |
1800 | { |
1801 | const __be32 *bp; | |
372ee163 | 1802 | int ret; |
e8d6c554 | 1803 | |
d001648e | 1804 | _enter("{%u}", call->unmarshall); |
e8d6c554 | 1805 | |
d001648e | 1806 | ret = afs_transfer_reply(call); |
372ee163 DH |
1807 | if (ret < 0) |
1808 | return ret; | |
e8d6c554 DH |
1809 | |
1810 | /* unmarshall the reply once we've received all of it */ | |
1811 | bp = call->buffer; | |
97e3043a | 1812 | /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */ |
e8d6c554 DH |
1813 | |
1814 | _leave(" = 0 [done]"); | |
1815 | return 0; | |
1816 | } | |
1817 | ||
1818 | /* | |
1819 | * FS.SetLock operation type | |
1820 | */ | |
1821 | static const struct afs_call_type afs_RXFSSetLock = { | |
1822 | .name = "FS.SetLock", | |
025db80c | 1823 | .op = afs_FS_SetLock, |
e8d6c554 | 1824 | .deliver = afs_deliver_fs_xxxx_lock, |
e8d6c554 DH |
1825 | .destructor = afs_flat_call_destructor, |
1826 | }; | |
1827 | ||
1828 | /* | |
1829 | * FS.ExtendLock operation type | |
1830 | */ | |
1831 | static const struct afs_call_type afs_RXFSExtendLock = { | |
1832 | .name = "FS.ExtendLock", | |
025db80c | 1833 | .op = afs_FS_ExtendLock, |
e8d6c554 | 1834 | .deliver = afs_deliver_fs_xxxx_lock, |
e8d6c554 DH |
1835 | .destructor = afs_flat_call_destructor, |
1836 | }; | |
1837 | ||
1838 | /* | |
1839 | * FS.ReleaseLock operation type | |
1840 | */ | |
1841 | static const struct afs_call_type afs_RXFSReleaseLock = { | |
1842 | .name = "FS.ReleaseLock", | |
025db80c | 1843 | .op = afs_FS_ReleaseLock, |
e8d6c554 | 1844 | .deliver = afs_deliver_fs_xxxx_lock, |
e8d6c554 DH |
1845 | .destructor = afs_flat_call_destructor, |
1846 | }; | |
1847 | ||
1848 | /* | |
d2ddc776 | 1849 | * Set a lock on a file |
e8d6c554 | 1850 | */ |
d2ddc776 | 1851 | int afs_fs_set_lock(struct afs_fs_cursor *fc, afs_lock_type_t type) |
e8d6c554 | 1852 | { |
d2ddc776 | 1853 | struct afs_vnode *vnode = fc->vnode; |
e8d6c554 | 1854 | struct afs_call *call; |
f044c884 | 1855 | struct afs_net *net = afs_v2net(vnode); |
e8d6c554 DH |
1856 | __be32 *bp; |
1857 | ||
1858 | _enter(""); | |
1859 | ||
f044c884 | 1860 | call = afs_alloc_flat_call(net, &afs_RXFSSetLock, 5 * 4, 6 * 4); |
e8d6c554 DH |
1861 | if (!call) |
1862 | return -ENOMEM; | |
1863 | ||
d2ddc776 | 1864 | call->key = fc->key; |
97e3043a | 1865 | call->reply[0] = vnode; |
e8d6c554 DH |
1866 | |
1867 | /* marshall the parameters */ | |
1868 | bp = call->request; | |
1869 | *bp++ = htonl(FSSETLOCK); | |
1870 | *bp++ = htonl(vnode->fid.vid); | |
1871 | *bp++ = htonl(vnode->fid.vnode); | |
1872 | *bp++ = htonl(vnode->fid.unique); | |
1873 | *bp++ = htonl(type); | |
1874 | ||
d2ddc776 | 1875 | afs_use_fs_server(call, fc->cbi); |
025db80c | 1876 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 1877 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
e8d6c554 DH |
1878 | } |
1879 | ||
1880 | /* | |
1881 | * extend a lock on a file | |
1882 | */ | |
d2ddc776 | 1883 | int afs_fs_extend_lock(struct afs_fs_cursor *fc) |
e8d6c554 | 1884 | { |
d2ddc776 | 1885 | struct afs_vnode *vnode = fc->vnode; |
e8d6c554 | 1886 | struct afs_call *call; |
f044c884 | 1887 | struct afs_net *net = afs_v2net(vnode); |
e8d6c554 DH |
1888 | __be32 *bp; |
1889 | ||
1890 | _enter(""); | |
1891 | ||
f044c884 | 1892 | call = afs_alloc_flat_call(net, &afs_RXFSExtendLock, 4 * 4, 6 * 4); |
e8d6c554 DH |
1893 | if (!call) |
1894 | return -ENOMEM; | |
1895 | ||
d2ddc776 | 1896 | call->key = fc->key; |
97e3043a | 1897 | call->reply[0] = vnode; |
e8d6c554 DH |
1898 | |
1899 | /* marshall the parameters */ | |
1900 | bp = call->request; | |
1901 | *bp++ = htonl(FSEXTENDLOCK); | |
1902 | *bp++ = htonl(vnode->fid.vid); | |
1903 | *bp++ = htonl(vnode->fid.vnode); | |
1904 | *bp++ = htonl(vnode->fid.unique); | |
1905 | ||
d2ddc776 | 1906 | afs_use_fs_server(call, fc->cbi); |
025db80c | 1907 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 1908 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
e8d6c554 DH |
1909 | } |
1910 | ||
1911 | /* | |
1912 | * release a lock on a file | |
1913 | */ | |
d2ddc776 | 1914 | int afs_fs_release_lock(struct afs_fs_cursor *fc) |
e8d6c554 | 1915 | { |
d2ddc776 | 1916 | struct afs_vnode *vnode = fc->vnode; |
e8d6c554 | 1917 | struct afs_call *call; |
f044c884 | 1918 | struct afs_net *net = afs_v2net(vnode); |
e8d6c554 DH |
1919 | __be32 *bp; |
1920 | ||
1921 | _enter(""); | |
1922 | ||
f044c884 | 1923 | call = afs_alloc_flat_call(net, &afs_RXFSReleaseLock, 4 * 4, 6 * 4); |
e8d6c554 DH |
1924 | if (!call) |
1925 | return -ENOMEM; | |
1926 | ||
d2ddc776 | 1927 | call->key = fc->key; |
97e3043a | 1928 | call->reply[0] = vnode; |
e8d6c554 DH |
1929 | |
1930 | /* marshall the parameters */ | |
1931 | bp = call->request; | |
1932 | *bp++ = htonl(FSRELEASELOCK); | |
1933 | *bp++ = htonl(vnode->fid.vid); | |
1934 | *bp++ = htonl(vnode->fid.vnode); | |
1935 | *bp++ = htonl(vnode->fid.unique); | |
1936 | ||
d2ddc776 | 1937 | afs_use_fs_server(call, fc->cbi); |
025db80c | 1938 | trace_afs_make_fs_call(call, &vnode->fid); |
d2ddc776 | 1939 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); |
c435ee34 DH |
1940 | } |
1941 | ||
1942 | /* | |
1943 | * Deliver reply data to an FS.GiveUpAllCallBacks operation. | |
1944 | */ | |
1945 | static int afs_deliver_fs_give_up_all_callbacks(struct afs_call *call) | |
1946 | { | |
1947 | return afs_transfer_reply(call); | |
1948 | } | |
1949 | ||
1950 | /* | |
1951 | * FS.GiveUpAllCallBacks operation type | |
1952 | */ | |
1953 | static const struct afs_call_type afs_RXFSGiveUpAllCallBacks = { | |
1954 | .name = "FS.GiveUpAllCallBacks", | |
025db80c | 1955 | .op = afs_FS_GiveUpAllCallBacks, |
c435ee34 DH |
1956 | .deliver = afs_deliver_fs_give_up_all_callbacks, |
1957 | .destructor = afs_flat_call_destructor, | |
1958 | }; | |
1959 | ||
1960 | /* | |
1961 | * Flush all the callbacks we have on a server. | |
1962 | */ | |
d2ddc776 DH |
1963 | int afs_fs_give_up_all_callbacks(struct afs_net *net, |
1964 | struct afs_server *server, | |
8b2a464c | 1965 | struct afs_addr_cursor *ac, |
d2ddc776 | 1966 | struct key *key) |
c435ee34 DH |
1967 | { |
1968 | struct afs_call *call; | |
1969 | __be32 *bp; | |
1970 | ||
1971 | _enter(""); | |
1972 | ||
d2ddc776 | 1973 | call = afs_alloc_flat_call(net, &afs_RXFSGiveUpAllCallBacks, 1 * 4, 0); |
c435ee34 DH |
1974 | if (!call) |
1975 | return -ENOMEM; | |
1976 | ||
1977 | call->key = key; | |
1978 | ||
1979 | /* marshall the parameters */ | |
1980 | bp = call->request; | |
1981 | *bp++ = htonl(FSGIVEUPALLCALLBACKS); | |
1982 | ||
1983 | /* Can't take a ref on server */ | |
d2ddc776 DH |
1984 | return afs_make_call(ac, call, GFP_NOFS, false); |
1985 | } | |
1986 | ||
1987 | /* | |
1988 | * Deliver reply data to an FS.GetCapabilities operation. | |
1989 | */ | |
1990 | static int afs_deliver_fs_get_capabilities(struct afs_call *call) | |
1991 | { | |
1992 | u32 count; | |
1993 | int ret; | |
1994 | ||
1995 | _enter("{%u,%zu/%u}", call->unmarshall, call->offset, call->count); | |
1996 | ||
1997 | again: | |
1998 | switch (call->unmarshall) { | |
1999 | case 0: | |
2000 | call->offset = 0; | |
2001 | call->unmarshall++; | |
2002 | ||
2003 | /* Extract the capabilities word count */ | |
2004 | case 1: | |
2005 | ret = afs_extract_data(call, &call->tmp, | |
2006 | 1 * sizeof(__be32), | |
2007 | true); | |
2008 | if (ret < 0) | |
2009 | return ret; | |
2010 | ||
2011 | count = ntohl(call->tmp); | |
2012 | ||
2013 | call->count = count; | |
2014 | call->count2 = count; | |
2015 | call->offset = 0; | |
2016 | call->unmarshall++; | |
2017 | ||
2018 | /* Extract capabilities words */ | |
2019 | case 2: | |
2020 | count = min(call->count, 16U); | |
2021 | ret = afs_extract_data(call, call->buffer, | |
2022 | count * sizeof(__be32), | |
2023 | call->count > 16); | |
2024 | if (ret < 0) | |
2025 | return ret; | |
2026 | ||
2027 | /* TODO: Examine capabilities */ | |
2028 | ||
2029 | call->count -= count; | |
2030 | if (call->count > 0) | |
2031 | goto again; | |
2032 | call->offset = 0; | |
2033 | call->unmarshall++; | |
2034 | break; | |
2035 | } | |
2036 | ||
2037 | _leave(" = 0 [done]"); | |
2038 | return 0; | |
2039 | } | |
2040 | ||
2041 | /* | |
2042 | * FS.GetCapabilities operation type | |
2043 | */ | |
2044 | static const struct afs_call_type afs_RXFSGetCapabilities = { | |
2045 | .name = "FS.GetCapabilities", | |
025db80c | 2046 | .op = afs_FS_GetCapabilities, |
d2ddc776 DH |
2047 | .deliver = afs_deliver_fs_get_capabilities, |
2048 | .destructor = afs_flat_call_destructor, | |
2049 | }; | |
2050 | ||
2051 | /* | |
2052 | * Probe a fileserver for the capabilities that it supports. This can | |
2053 | * return up to 196 words. | |
2054 | */ | |
2055 | int afs_fs_get_capabilities(struct afs_net *net, | |
2056 | struct afs_server *server, | |
2057 | struct afs_addr_cursor *ac, | |
2058 | struct key *key) | |
2059 | { | |
2060 | struct afs_call *call; | |
2061 | __be32 *bp; | |
2062 | ||
2063 | _enter(""); | |
2064 | ||
2065 | call = afs_alloc_flat_call(net, &afs_RXFSGetCapabilities, 1 * 4, 16 * 4); | |
2066 | if (!call) | |
2067 | return -ENOMEM; | |
2068 | ||
2069 | call->key = key; | |
2070 | ||
2071 | /* marshall the parameters */ | |
2072 | bp = call->request; | |
2073 | *bp++ = htonl(FSGETCAPABILITIES); | |
2074 | ||
2075 | /* Can't take a ref on server */ | |
025db80c | 2076 | trace_afs_make_fs_call(call, NULL); |
d2ddc776 | 2077 | return afs_make_call(ac, call, GFP_NOFS, false); |
e8d6c554 | 2078 | } |
5cf9dd55 DH |
2079 | |
2080 | /* | |
2081 | * Deliver reply data to an FS.FetchStatus with no vnode. | |
2082 | */ | |
2083 | static int afs_deliver_fs_fetch_status(struct afs_call *call) | |
2084 | { | |
2085 | struct afs_file_status *status = call->reply[1]; | |
2086 | struct afs_callback *callback = call->reply[2]; | |
2087 | struct afs_volsync *volsync = call->reply[3]; | |
2088 | struct afs_vnode *vnode = call->reply[0]; | |
2089 | const __be32 *bp; | |
2090 | int ret; | |
2091 | ||
2092 | ret = afs_transfer_reply(call); | |
2093 | if (ret < 0) | |
2094 | return ret; | |
2095 | ||
2096 | _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode); | |
2097 | ||
2098 | /* unmarshall the reply once we've received all of it */ | |
2099 | bp = call->buffer; | |
5f702c8e | 2100 | xdr_decode_AFSFetchStatus(call, &bp, status, vnode, |
0c3a5ac2 | 2101 | &call->expected_version, NULL); |
5cf9dd55 DH |
2102 | callback[call->count].version = ntohl(bp[0]); |
2103 | callback[call->count].expiry = ntohl(bp[1]); | |
2104 | callback[call->count].type = ntohl(bp[2]); | |
2105 | if (vnode) | |
2106 | xdr_decode_AFSCallBack(call, vnode, &bp); | |
2107 | else | |
2108 | bp += 3; | |
2109 | if (volsync) | |
2110 | xdr_decode_AFSVolSync(&bp, volsync); | |
2111 | ||
2112 | _leave(" = 0 [done]"); | |
2113 | return 0; | |
2114 | } | |
2115 | ||
2116 | /* | |
2117 | * FS.FetchStatus operation type | |
2118 | */ | |
2119 | static const struct afs_call_type afs_RXFSFetchStatus = { | |
2120 | .name = "FS.FetchStatus", | |
2121 | .op = afs_FS_FetchStatus, | |
2122 | .deliver = afs_deliver_fs_fetch_status, | |
2123 | .destructor = afs_flat_call_destructor, | |
2124 | }; | |
2125 | ||
2126 | /* | |
2127 | * Fetch the status information for a fid without needing a vnode handle. | |
2128 | */ | |
2129 | int afs_fs_fetch_status(struct afs_fs_cursor *fc, | |
2130 | struct afs_net *net, | |
2131 | struct afs_fid *fid, | |
2132 | struct afs_file_status *status, | |
2133 | struct afs_callback *callback, | |
2134 | struct afs_volsync *volsync) | |
2135 | { | |
2136 | struct afs_call *call; | |
2137 | __be32 *bp; | |
2138 | ||
2139 | _enter(",%x,{%x:%u},,", | |
2140 | key_serial(fc->key), fid->vid, fid->vnode); | |
2141 | ||
2142 | call = afs_alloc_flat_call(net, &afs_RXFSFetchStatus, 16, (21 + 3 + 6) * 4); | |
2143 | if (!call) { | |
2144 | fc->ac.error = -ENOMEM; | |
2145 | return -ENOMEM; | |
2146 | } | |
2147 | ||
2148 | call->key = fc->key; | |
2149 | call->reply[0] = NULL; /* vnode for fid[0] */ | |
2150 | call->reply[1] = status; | |
2151 | call->reply[2] = callback; | |
2152 | call->reply[3] = volsync; | |
0c3a5ac2 | 2153 | call->expected_version = 1; /* vnode->status.data_version */ |
5cf9dd55 DH |
2154 | |
2155 | /* marshall the parameters */ | |
2156 | bp = call->request; | |
2157 | bp[0] = htonl(FSFETCHSTATUS); | |
2158 | bp[1] = htonl(fid->vid); | |
2159 | bp[2] = htonl(fid->vnode); | |
2160 | bp[3] = htonl(fid->unique); | |
2161 | ||
2162 | call->cb_break = fc->cb_break; | |
2163 | afs_use_fs_server(call, fc->cbi); | |
2164 | trace_afs_make_fs_call(call, fid); | |
2165 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); | |
2166 | } | |
2167 | ||
2168 | /* | |
2169 | * Deliver reply data to an FS.InlineBulkStatus call | |
2170 | */ | |
2171 | static int afs_deliver_fs_inline_bulk_status(struct afs_call *call) | |
2172 | { | |
2173 | struct afs_file_status *statuses; | |
2174 | struct afs_callback *callbacks; | |
2175 | struct afs_vnode *vnode = call->reply[0]; | |
2176 | const __be32 *bp; | |
2177 | u32 tmp; | |
2178 | int ret; | |
2179 | ||
2180 | _enter("{%u}", call->unmarshall); | |
2181 | ||
2182 | switch (call->unmarshall) { | |
2183 | case 0: | |
2184 | call->offset = 0; | |
2185 | call->unmarshall++; | |
2186 | ||
2187 | /* Extract the file status count and array in two steps */ | |
2188 | case 1: | |
2189 | _debug("extract status count"); | |
2190 | ret = afs_extract_data(call, &call->tmp, 4, true); | |
2191 | if (ret < 0) | |
2192 | return ret; | |
2193 | ||
2194 | tmp = ntohl(call->tmp); | |
2195 | _debug("status count: %u/%u", tmp, call->count2); | |
2196 | if (tmp != call->count2) | |
5f702c8e | 2197 | return afs_protocol_error(call, -EBADMSG); |
5cf9dd55 DH |
2198 | |
2199 | call->count = 0; | |
2200 | call->unmarshall++; | |
2201 | more_counts: | |
2202 | call->offset = 0; | |
2203 | ||
2204 | case 2: | |
2205 | _debug("extract status array %u", call->count); | |
2206 | ret = afs_extract_data(call, call->buffer, 21 * 4, true); | |
2207 | if (ret < 0) | |
2208 | return ret; | |
2209 | ||
2210 | bp = call->buffer; | |
2211 | statuses = call->reply[1]; | |
5f702c8e | 2212 | if (xdr_decode_AFSFetchStatus(call, &bp, &statuses[call->count], |
dd9fbcb8 DH |
2213 | call->count == 0 ? vnode : NULL, |
2214 | NULL, NULL) < 0) | |
5f702c8e | 2215 | return afs_protocol_error(call, -EBADMSG); |
5cf9dd55 DH |
2216 | |
2217 | call->count++; | |
2218 | if (call->count < call->count2) | |
2219 | goto more_counts; | |
2220 | ||
2221 | call->count = 0; | |
2222 | call->unmarshall++; | |
2223 | call->offset = 0; | |
2224 | ||
2225 | /* Extract the callback count and array in two steps */ | |
2226 | case 3: | |
2227 | _debug("extract CB count"); | |
2228 | ret = afs_extract_data(call, &call->tmp, 4, true); | |
2229 | if (ret < 0) | |
2230 | return ret; | |
2231 | ||
2232 | tmp = ntohl(call->tmp); | |
2233 | _debug("CB count: %u", tmp); | |
2234 | if (tmp != call->count2) | |
5f702c8e | 2235 | return afs_protocol_error(call, -EBADMSG); |
5cf9dd55 DH |
2236 | call->count = 0; |
2237 | call->unmarshall++; | |
2238 | more_cbs: | |
2239 | call->offset = 0; | |
2240 | ||
2241 | case 4: | |
2242 | _debug("extract CB array"); | |
2243 | ret = afs_extract_data(call, call->buffer, 3 * 4, true); | |
2244 | if (ret < 0) | |
2245 | return ret; | |
2246 | ||
2247 | _debug("unmarshall CB array"); | |
2248 | bp = call->buffer; | |
2249 | callbacks = call->reply[2]; | |
2250 | callbacks[call->count].version = ntohl(bp[0]); | |
2251 | callbacks[call->count].expiry = ntohl(bp[1]); | |
2252 | callbacks[call->count].type = ntohl(bp[2]); | |
2253 | statuses = call->reply[1]; | |
2254 | if (call->count == 0 && vnode && statuses[0].abort_code == 0) | |
2255 | xdr_decode_AFSCallBack(call, vnode, &bp); | |
2256 | call->count++; | |
2257 | if (call->count < call->count2) | |
2258 | goto more_cbs; | |
2259 | ||
2260 | call->offset = 0; | |
2261 | call->unmarshall++; | |
2262 | ||
2263 | case 5: | |
2264 | ret = afs_extract_data(call, call->buffer, 6 * 4, false); | |
2265 | if (ret < 0) | |
2266 | return ret; | |
2267 | ||
2268 | bp = call->buffer; | |
2269 | if (call->reply[3]) | |
2270 | xdr_decode_AFSVolSync(&bp, call->reply[3]); | |
2271 | ||
2272 | call->offset = 0; | |
2273 | call->unmarshall++; | |
2274 | ||
2275 | case 6: | |
2276 | break; | |
2277 | } | |
2278 | ||
2279 | _leave(" = 0 [done]"); | |
2280 | return 0; | |
2281 | } | |
2282 | ||
2283 | /* | |
2284 | * FS.InlineBulkStatus operation type | |
2285 | */ | |
2286 | static const struct afs_call_type afs_RXFSInlineBulkStatus = { | |
2287 | .name = "FS.InlineBulkStatus", | |
2288 | .op = afs_FS_InlineBulkStatus, | |
2289 | .deliver = afs_deliver_fs_inline_bulk_status, | |
2290 | .destructor = afs_flat_call_destructor, | |
2291 | }; | |
2292 | ||
2293 | /* | |
2294 | * Fetch the status information for up to 50 files | |
2295 | */ | |
2296 | int afs_fs_inline_bulk_status(struct afs_fs_cursor *fc, | |
2297 | struct afs_net *net, | |
2298 | struct afs_fid *fids, | |
2299 | struct afs_file_status *statuses, | |
2300 | struct afs_callback *callbacks, | |
2301 | unsigned int nr_fids, | |
2302 | struct afs_volsync *volsync) | |
2303 | { | |
2304 | struct afs_call *call; | |
2305 | __be32 *bp; | |
2306 | int i; | |
2307 | ||
2308 | _enter(",%x,{%x:%u},%u", | |
2309 | key_serial(fc->key), fids[0].vid, fids[1].vnode, nr_fids); | |
2310 | ||
2311 | call = afs_alloc_flat_call(net, &afs_RXFSInlineBulkStatus, | |
2312 | (2 + nr_fids * 3) * 4, | |
2313 | 21 * 4); | |
2314 | if (!call) { | |
2315 | fc->ac.error = -ENOMEM; | |
2316 | return -ENOMEM; | |
2317 | } | |
2318 | ||
2319 | call->key = fc->key; | |
2320 | call->reply[0] = NULL; /* vnode for fid[0] */ | |
2321 | call->reply[1] = statuses; | |
2322 | call->reply[2] = callbacks; | |
2323 | call->reply[3] = volsync; | |
2324 | call->count2 = nr_fids; | |
2325 | ||
2326 | /* marshall the parameters */ | |
2327 | bp = call->request; | |
2328 | *bp++ = htonl(FSINLINEBULKSTATUS); | |
2329 | *bp++ = htonl(nr_fids); | |
2330 | for (i = 0; i < nr_fids; i++) { | |
2331 | *bp++ = htonl(fids[i].vid); | |
2332 | *bp++ = htonl(fids[i].vnode); | |
2333 | *bp++ = htonl(fids[i].unique); | |
2334 | } | |
2335 | ||
2336 | call->cb_break = fc->cb_break; | |
2337 | afs_use_fs_server(call, fc->cbi); | |
2338 | trace_afs_make_fs_call(call, &fids[0]); | |
2339 | return afs_make_call(&fc->ac, call, GFP_NOFS, false); | |
2340 | } |