1 /* NFSv4.1 client for Windows
2 * Copyright � 2012 The Regents of the University of Michigan
3 *
4 * Olga Kornievskaia <aglo@umich.edu>
5 * Casey Bodley <cbodley@umich.edu>
6 *
7 * This library is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU Lesser General Public License as published by
9 * the Free Software Foundation; either version 2.1 of the License, or (at
10 * your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful, but
13 * without any warranty; without even the implied warranty of merchantability
14 * or fitness for a particular purpose. See the GNU Lesser General Public
15 * License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 */
21
22 #ifndef __NFS41__
23 #define __NFS41__
24
25 #include "util.h"
26 #include "list.h"
27
28
29 struct __nfs41_session;
30 struct __nfs41_client;
31 struct __rpc_client;
32 struct __nfs41_root;
33
34 struct _FILE_GET_EA_INFORMATION;
35 struct _FILE_FULL_EA_INFORMATION;
36
37 typedef struct __nfs41_superblock {
38 nfs41_fsid fsid;
39 struct list_entry entry; /* position in nfs41_server.superblocks */
40
41 bitmap4 supported_attrs;
42 bitmap4 suppattr_exclcreat;
43 bitmap4 default_getattr;
44
45 nfstime4 time_delta;
46 uint64_t maxread;
47 uint64_t maxwrite;
48
49 /* constant filesystem attributes */
50 unsigned int layout_types : 3;
51 unsigned int aclsupport : 3;
52 unsigned int cansettime : 1;
53 unsigned int link_support : 1;
54 unsigned int symlink_support : 1;
55 unsigned int ea_support : 1;
56 unsigned int case_preserving : 1;
57 unsigned int case_insensitive : 1;
58
59 /* variable filesystem attributes */
60 uint64_t space_avail;
61 uint64_t space_free;
62 uint64_t space_total;
63 time_t cache_expiration; /* applies to space_ attributes */
64
65 SRWLOCK lock;
66 } nfs41_superblock;
67
68 typedef struct __nfs41_superblock_list {
69 struct list_entry head;
70 SRWLOCK lock;
71 } nfs41_superblock_list;
72
73 struct server_addrs {
74 multi_addr4 addrs; /* list of addrs we've used with this server */
75 uint32_t next_index;
76 SRWLOCK lock;
77 };
78
79 typedef struct __nfs41_server {
80 char scope[NFS4_OPAQUE_LIMIT]; /* server_scope from exchangeid */
81 char owner[NFS4_OPAQUE_LIMIT]; /* server_owner.major_id from exchangeid */
82 struct server_addrs addrs;
83 nfs41_superblock_list superblocks;
84 struct nfs41_name_cache *name_cache;
85 struct list_entry entry; /* position in global server list */
86 LONG ref_count;
87 } nfs41_server;
88
89 enum delegation_status {
90 DELEGATION_GRANTED,
91 DELEGATION_RETURNING,
92 DELEGATION_RETURNED,
93 };
94
95 typedef struct __nfs41_delegation_state {
96 open_delegation4 state;
97 nfs41_abs_path path;
98 nfs41_path_fh parent;
99 nfs41_path_fh file;
100 struct list_entry client_entry; /* entry in nfs41_client.delegations */
101 LONG ref_count;
102
103 enum delegation_status status;
104 SRWLOCK lock;
105 CONDITION_VARIABLE cond;
106
107 bool_t revoked; /* for recovery, accessed under client.state.lock */
108
109 HANDLE srv_open; /* for rdbss cache invalidation */
110 } nfs41_delegation_state;
111
112 typedef struct __nfs41_lock_state {
113 struct list_entry open_entry; /* entry in nfs41_open_state.locks */
114 uint64_t offset;
115 uint64_t length;
116 uint32_t exclusive : 1;
117 uint32_t delegated : 1; /* whether or not there is state on the server */
118 uint32_t id : 30;
119 } nfs41_lock_state;
120
121 /* nfs41_open_state reference counting:
122 * one reference is held implicitly by the driver (initialized to 1 on
123 * OPEN and released on CLOSE). other references must be held during
124 * upcalls to prevent a parallel CLOSE from freeing it prematurely. by
125 * calling upcall_open_state_ref() when parsing the upcall, you are
126 * guaranteed a matching dereference on upcall_cleanup() */
127 typedef struct __nfs41_open_state {
128 nfs41_abs_path path;
129 nfs41_path_fh parent;
130 nfs41_path_fh file;
131 nfs41_readdir_cookie cookie;
132 struct __nfs41_session *session;
133 uint32_t type;
134 bool_t do_close;
135 stateid4 stateid;
136 state_owner4 owner;
137 struct __pnfs_layout_state *layout;
138 struct list_entry client_entry; /* entry in nfs41_client.opens */
139 SRWLOCK lock;
140 LONG ref_count;
141 uint32_t share_access;
142 uint32_t share_deny;
143 uint64_t pnfs_last_offset; /* for layoutcommit */
144
145 struct {
146 nfs41_delegation_state *state;
147 bool_t reclaim;
148 CONDITION_VARIABLE cond;
149 } delegation;
150
151 struct { /* list of open lock state for recovery */
152 stateid4 stateid;
153 struct list_entry list;
154 uint32_t counter;
155 CRITICAL_SECTION lock;
156 } locks;
157
158 struct {
159 struct _FILE_GET_EA_INFORMATION *list;
160 uint32_t index;
161 CRITICAL_SECTION lock;
162 } ea;
163
164 HANDLE srv_open; /* for data cache invalidation */
165 } nfs41_open_state;
166
167 typedef struct __nfs41_rpc_clnt {
168 struct __rpc_client *rpc;
169 SRWLOCK lock;
170 HANDLE cond;
171 struct __nfs41_client *client;
172 multi_addr4 addrs;
173 uint32_t addr_index; /* index of addr we're using */
174 uint32_t wsize;
175 uint32_t rsize;
176 uint32_t version;
177 uint32_t sec_flavor;
178 uint32_t uid;
179 uint32_t gid;
180 char server_name[NI_MAXHOST];
181 bool_t is_valid_session;
182 bool_t in_recovery;
183 bool_t needcb;
184 } nfs41_rpc_clnt;
185
186 struct client_state {
187 struct list_entry opens; /* list of associated nfs41_open_state */
188 struct list_entry delegations; /* list of associated delegations */
189 CRITICAL_SECTION lock;
190 };
191
192 typedef struct __nfs41_client {
193 nfs41_server *server;
194 client_owner4 owner;
195 uint64_t clnt_id;
196 uint32_t seq_id;
197 uint32_t roles;
198 SRWLOCK exid_lock;
199 struct __nfs41_session *session;
200 SRWLOCK session_lock;
201 nfs41_rpc_clnt *rpc;
202 bool_t is_data;
203 struct pnfs_layout_list *layouts;
204 struct pnfs_file_device_list *devices;
205 struct list_entry root_entry; /* position in nfs41_root.clients */
206 struct __nfs41_root *root;
207
208 struct {
209 CONDITION_VARIABLE cond;
210 CRITICAL_SECTION lock;
211 bool_t in_recovery;
212 } recovery;
213
214 /* for state recovery on server reboot */
215 struct client_state state;
216 } nfs41_client;
217
218 #define NFS41_MAX_NUM_SLOTS NFS41_MAX_RPC_REQS
219 typedef struct __nfs41_slot_table {
220 uint32_t seq_nums[NFS41_MAX_NUM_SLOTS];
221 uint32_t used_slots[NFS41_MAX_NUM_SLOTS];
222 uint32_t max_slots;
223 uint32_t highest_used;
224 uint32_t num_used;
225 ULONGLONG target_delay;
226 CRITICAL_SECTION lock;
227 CONDITION_VARIABLE cond;
228 } nfs41_slot_table;
229
230 typedef struct __nfs41_channel_attrs {
231 uint32_t ca_headerpadsize;
232 uint32_t ca_maxrequestsize;
233 uint32_t ca_maxresponsesize;
234 uint32_t ca_maxresponsesize_cached;
235 uint32_t ca_maxoperations;
236 uint32_t ca_maxrequests;
237 uint32_t *ca_rdma_ird;
238 } nfs41_channel_attrs;
239
240 struct replay_cache {
241 unsigned char buffer[NFS41_MAX_SERVER_CACHE];
242 uint32_t length;
243 };
244
245 typedef struct __nfs41_cb_session {
246 struct {
247 struct replay_cache arg;
248 struct replay_cache res;
249 } replay;
250 const unsigned char *cb_sessionid; /* -> nfs41_session.session_id */
251 uint32_t cb_seqnum;
252 uint32_t cb_slotid;
253 } nfs41_cb_session;
254
255 typedef struct __nfs41_session {
256 nfs41_client *client;
257 unsigned char session_id[NFS4_SESSIONID_SIZE];
258 nfs41_channel_attrs fore_chan_attrs;
259 nfs41_channel_attrs back_chan_attrs;
260 uint32_t lease_time;
261 nfs41_slot_table table;
262 // array of slots
263 HANDLE renew_thread;
264 bool_t isValidState;
265 uint32_t flags;
266 nfs41_cb_session cb_session;
267 } nfs41_session;
268
269 /* nfs41_root reference counting:
270 * similar to nfs41_open_state, the driver holds an implicit reference
271 * between MOUNT and UNMOUNT. all other upcalls use upcall_root_ref() on
272 * upcall_parse(), which prevents the root/clients from being freed and
273 * guarantees a matching deref on upcall_cleanup() */
274 typedef struct __nfs41_root {
275 client_owner4 client_owner;
276 CRITICAL_SECTION lock;
277 struct list_entry clients;
278 uint32_t wsize;
279 uint32_t rsize;
280 LONG ref_count;
281 uint32_t uid;
282 uint32_t gid;
283 DWORD sec_flavor;
284 } nfs41_root;
285
286
287 /* nfs41_namespace.c */
288 int nfs41_root_create(
289 IN const char *name,
290 IN uint32_t sec_flavor,
291 IN uint32_t wsize,
292 IN uint32_t rsize,
293 OUT nfs41_root **root_out);
294
295 void nfs41_root_ref(
296 IN nfs41_root *root);
297
298 void nfs41_root_deref(
299 IN nfs41_root *root);
300
301 int nfs41_root_mount_addrs(
302 IN nfs41_root *root,
303 IN const multi_addr4 *addrs,
304 IN bool_t is_data,
305 IN OPTIONAL uint32_t lease_time,
306 OUT nfs41_client **client_out);
307
308 int nfs41_root_mount_server(
309 IN nfs41_root *root,
310 IN nfs41_server *server,
311 IN bool_t is_data,
312 IN OPTIONAL uint32_t lease_time,
313 OUT nfs41_client **client_out);
314
315 int nfs41_root_mount_referral(
316 IN nfs41_root *root,
317 IN const fs_locations4 *locations,
318 OUT const fs_location4 **loc_out,
319 OUT nfs41_client **client_out);
320
nfs41_root_session(IN nfs41_root * root)321 static __inline nfs41_session* nfs41_root_session(
322 IN nfs41_root *root)
323 {
324 nfs41_client *client;
325 /* return a session for the server at the root of the namespace.
326 * because we created it on mount, it's the first one in the list */
327 EnterCriticalSection(&root->lock);
328 client = list_container(root->clients.next, nfs41_client, root_entry);
329 LeaveCriticalSection(&root->lock);
330 return client->session;
331 }
332
333
334 /* nfs41_session.c */
335 int nfs41_session_create(
336 IN nfs41_client *client,
337 IN nfs41_session **session_out);
338
339 int nfs41_session_renew(
340 IN nfs41_session *session);
341
342 int nfs41_session_set_lease(
343 IN nfs41_session *session,
344 IN uint32_t lease_time);
345
346 void nfs41_session_free(
347 IN nfs41_session *session);
348
349 void nfs41_session_bump_seq(
350 IN nfs41_session *session,
351 IN uint32_t slotid,
352 IN uint32_t target_highest_slotid);
353
354 void nfs41_session_free_slot(
355 IN nfs41_session *session,
356 IN uint32_t slotid);
357
358 void nfs41_session_get_slot(
359 IN nfs41_session *session,
360 OUT uint32_t *slot,
361 OUT uint32_t *seq,
362 OUT uint32_t *highest);
363
364 int nfs41_session_recall_slot(
365 IN nfs41_session *session,
366 IN OUT uint32_t target_highest_slotid);
367
368 struct __nfs41_sequence_args;
369 void nfs41_session_sequence(
370 struct __nfs41_sequence_args *args,
371 nfs41_session *session,
372 bool_t cachethis);
373
374 int nfs41_session_bad_slot(
375 IN nfs41_session *session,
376 IN OUT struct __nfs41_sequence_args *args);
377
378
379 /* nfs41_server.c */
380 void nfs41_server_list_init();
381
382 int nfs41_server_resolve(
383 IN const char *hostname,
384 IN unsigned short port,
385 OUT multi_addr4 *addrs);
386
387 int nfs41_server_find_or_create(
388 IN const char *server_owner_major_id,
389 IN const char *server_scope,
390 IN const netaddr4 *addr,
391 OUT nfs41_server **server_out);
392
393 void nfs41_server_ref(
394 IN nfs41_server *server);
395
396 void nfs41_server_deref(
397 IN nfs41_server *server);
398
399 void nfs41_server_addrs(
400 IN nfs41_server *server,
401 OUT multi_addr4 *addrs);
402
403
404 /* nfs41_client.c */
405 int nfs41_client_owner(
406 IN const char *name,
407 IN uint32_t sec_flavor,
408 OUT client_owner4 *owner);
409
410 uint32_t nfs41_exchange_id_flags(
411 IN bool_t is_data);
412
413 struct __nfs41_exchange_id_res;
414
415 int nfs41_client_create(
416 IN nfs41_rpc_clnt *rpc,
417 IN const client_owner4 *owner,
418 IN bool_t is_data,
419 IN const struct __nfs41_exchange_id_res *exchangeid,
420 OUT nfs41_client **client_out);
421
422 int nfs41_client_renew(
423 IN nfs41_client *client);
424
425 void nfs41_client_free(
426 IN nfs41_client *client);
427
client_server(IN nfs41_client * client)428 static __inline nfs41_server* client_server(
429 IN nfs41_client *client)
430 {
431 /* the client's server could change during nfs41_client_renew(),
432 * so access to client->server must be protected */
433 nfs41_server *server;
434 AcquireSRWLockShared(&client->exid_lock);
435 server = client->server;
436 ReleaseSRWLockShared(&client->exid_lock);
437 return server;
438 }
439
440
441 /* nfs41_superblock.c */
442 int nfs41_superblock_for_fh(
443 IN nfs41_session *session,
444 IN const nfs41_fsid *fsid,
445 IN const nfs41_fh *parent OPTIONAL,
446 OUT nfs41_path_fh *file);
447
nfs41_superblock_getattr_mask(IN const nfs41_superblock * superblock,OUT bitmap4 * attrs)448 static __inline void nfs41_superblock_getattr_mask(
449 IN const nfs41_superblock *superblock,
450 OUT bitmap4 *attrs)
451 {
452 memcpy(attrs, &superblock->default_getattr, sizeof(bitmap4));
453 }
nfs41_superblock_supported_attrs(IN const nfs41_superblock * superblock,IN OUT bitmap4 * attrs)454 static __inline void nfs41_superblock_supported_attrs(
455 IN const nfs41_superblock *superblock,
456 IN OUT bitmap4 *attrs)
457 {
458 bitmap_intersect(attrs, &superblock->supported_attrs);
459 }
nfs41_superblock_supported_attrs_exclcreat(IN const nfs41_superblock * superblock,IN OUT bitmap4 * attrs)460 static __inline void nfs41_superblock_supported_attrs_exclcreat(
461 IN const nfs41_superblock *superblock,
462 IN OUT bitmap4 *attrs)
463 {
464 bitmap_intersect(attrs, &superblock->suppattr_exclcreat);
465 }
466
467 struct _FILE_FS_ATTRIBUTE_INFORMATION;
468 void nfs41_superblock_fs_attributes(
469 IN const nfs41_superblock *superblock,
470 OUT struct _FILE_FS_ATTRIBUTE_INFORMATION *FsAttrs);
471
472 void nfs41_superblock_space_changed(
473 IN nfs41_superblock *superblock);
474
475 void nfs41_superblock_list_init(
476 IN nfs41_superblock_list *superblocks);
477
478 void nfs41_superblock_list_free(
479 IN nfs41_superblock_list *superblocks);
480
481
482 /* nfs41_rpc.c */
483 int nfs41_rpc_clnt_create(
484 IN const multi_addr4 *addrs,
485 IN uint32_t wsize,
486 IN uint32_t rsize,
487 IN uint32_t uid,
488 IN uint32_t gid,
489 IN uint32_t sec_flavor,
490 OUT nfs41_rpc_clnt **rpc_out);
491
492 void nfs41_rpc_clnt_free(
493 IN nfs41_rpc_clnt *rpc);
494
495 int nfs41_send_compound(
496 IN nfs41_rpc_clnt *rpc,
497 IN char *inbuf,
498 OUT char *outbuf);
499
nfs41_rpc_netaddr(IN nfs41_rpc_clnt * rpc)500 static __inline netaddr4* nfs41_rpc_netaddr(
501 IN nfs41_rpc_clnt *rpc)
502 {
503 uint32_t id;
504 AcquireSRWLockShared(&rpc->lock);
505 /* only addr_index needs to be protected, as rpc->addrs is write-once */
506 id = rpc->addr_index;
507 ReleaseSRWLockShared(&rpc->lock);
508
509 /* return the netaddr used to create the rpc client */
510 return &rpc->addrs.arr[id];
511 }
512
513
514 /* open.c */
515 void nfs41_open_state_ref(
516 IN nfs41_open_state *state);
517
518 void nfs41_open_state_deref(
519 IN nfs41_open_state *state);
520
521 struct __stateid_arg;
522 void nfs41_open_stateid_arg(
523 IN nfs41_open_state *state,
524 OUT struct __stateid_arg *arg);
525
526
527 /* ea.c */
528 int nfs41_ea_set(
529 IN nfs41_open_state *state,
530 IN struct _FILE_FULL_EA_INFORMATION *ea);
531
532 #endif /* __NFS41__ */
533