4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
27 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, 2012, Intel Corporation.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
36 * lustre/llite/llite_lib.c
38 * Lustre Light Super operations
41 #define DEBUG_SUBSYSTEM S_LLITE
43 #include <linux/module.h>
44 #include <linux/types.h>
47 #include <lustre_lite.h>
48 #include <lustre_ha.h>
49 #include <lustre_dlm.h>
50 #include <lprocfs_status.h>
51 #include <lustre_disk.h>
52 #include <lustre_param.h>
53 #include <lustre_log.h>
54 #include <cl_object.h>
55 #include <obd_cksum.h>
56 #include "llite_internal.h"
58 struct kmem_cache
*ll_file_data_slab
;
59 struct proc_dir_entry
*proc_lustre_fs_root
;
61 static LIST_HEAD(ll_super_blocks
);
62 static DEFINE_SPINLOCK(ll_sb_lock
);
65 #define log2(n) ffz(~(n))
68 static struct ll_sb_info
*ll_init_sbi(void)
70 struct ll_sb_info
*sbi
= NULL
;
72 unsigned long lru_page_max
;
77 OBD_ALLOC(sbi
, sizeof(*sbi
));
81 spin_lock_init(&sbi
->ll_lock
);
82 mutex_init(&sbi
->ll_lco
.lco_lock
);
83 spin_lock_init(&sbi
->ll_pp_extent_lock
);
84 spin_lock_init(&sbi
->ll_process_lock
);
85 sbi
->ll_rw_stats_on
= 0;
88 pages
= si
.totalram
- si
.totalhigh
;
89 if (pages
>> (20 - PAGE_CACHE_SHIFT
) < 512) {
90 lru_page_max
= pages
/ 2;
92 lru_page_max
= (pages
/ 4) * 3;
95 /* initialize lru data */
96 atomic_set(&sbi
->ll_cache
.ccc_users
, 0);
97 sbi
->ll_cache
.ccc_lru_max
= lru_page_max
;
98 atomic_set(&sbi
->ll_cache
.ccc_lru_left
, lru_page_max
);
99 spin_lock_init(&sbi
->ll_cache
.ccc_lru_lock
);
100 INIT_LIST_HEAD(&sbi
->ll_cache
.ccc_lru
);
102 sbi
->ll_ra_info
.ra_max_pages_per_file
= min(pages
/ 32,
103 SBI_DEFAULT_READAHEAD_MAX
);
104 sbi
->ll_ra_info
.ra_max_pages
= sbi
->ll_ra_info
.ra_max_pages_per_file
;
105 sbi
->ll_ra_info
.ra_max_read_ahead_whole_pages
=
106 SBI_DEFAULT_READAHEAD_WHOLE_MAX
;
107 INIT_LIST_HEAD(&sbi
->ll_conn_chain
);
108 INIT_LIST_HEAD(&sbi
->ll_orphan_dentry_list
);
110 ll_generate_random_uuid(uuid
);
111 class_uuid_unparse(uuid
, &sbi
->ll_sb_uuid
);
112 CDEBUG(D_CONFIG
, "generated uuid: %s\n", sbi
->ll_sb_uuid
.uuid
);
114 spin_lock(&ll_sb_lock
);
115 list_add_tail(&sbi
->ll_list
, &ll_super_blocks
);
116 spin_unlock(&ll_sb_lock
);
118 sbi
->ll_flags
|= LL_SBI_VERBOSE
;
119 sbi
->ll_flags
|= LL_SBI_CHECKSUM
;
121 sbi
->ll_flags
|= LL_SBI_LRU_RESIZE
;
123 for (i
= 0; i
<= LL_PROCESS_HIST_MAX
; i
++) {
124 spin_lock_init(&sbi
->ll_rw_extents_info
.pp_extents
[i
].
126 spin_lock_init(&sbi
->ll_rw_extents_info
.pp_extents
[i
].
130 /* metadata statahead is enabled by default */
131 sbi
->ll_sa_max
= LL_SA_RPC_DEF
;
132 atomic_set(&sbi
->ll_sa_total
, 0);
133 atomic_set(&sbi
->ll_sa_wrong
, 0);
134 atomic_set(&sbi
->ll_agl_total
, 0);
135 sbi
->ll_flags
|= LL_SBI_AGL_ENABLED
;
140 static void ll_free_sbi(struct super_block
*sb
)
142 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
145 spin_lock(&ll_sb_lock
);
146 list_del(&sbi
->ll_list
);
147 spin_unlock(&ll_sb_lock
);
148 OBD_FREE(sbi
, sizeof(*sbi
));
152 static int client_common_fill_super(struct super_block
*sb
, char *md
, char *dt
,
153 struct vfsmount
*mnt
)
155 struct inode
*root
= 0;
156 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
157 struct obd_device
*obd
;
158 struct obd_capa
*oc
= NULL
;
159 struct obd_statfs
*osfs
= NULL
;
160 struct ptlrpc_request
*request
= NULL
;
161 struct obd_connect_data
*data
= NULL
;
162 struct obd_uuid
*uuid
;
163 struct md_op_data
*op_data
;
164 struct lustre_md lmd
;
166 int size
, err
, checksum
;
168 obd
= class_name2obd(md
);
170 CERROR("MD %s: not setup or attached\n", md
);
184 if (proc_lustre_fs_root
) {
185 err
= lprocfs_register_mountpoint(proc_lustre_fs_root
, sb
,
188 CERROR("could not register mount in /proc/fs/lustre\n");
191 /* indicate the features supported by this client */
192 data
->ocd_connect_flags
= OBD_CONNECT_IBITS
| OBD_CONNECT_NODEVOH
|
193 OBD_CONNECT_ATTRFID
|
194 OBD_CONNECT_VERSION
| OBD_CONNECT_BRW_SIZE
|
195 OBD_CONNECT_MDS_CAPA
| OBD_CONNECT_OSS_CAPA
|
196 OBD_CONNECT_CANCELSET
| OBD_CONNECT_FID
|
197 OBD_CONNECT_AT
| OBD_CONNECT_LOV_V3
|
198 OBD_CONNECT_RMT_CLIENT
| OBD_CONNECT_VBR
|
199 OBD_CONNECT_FULL20
| OBD_CONNECT_64BITHASH
|
200 OBD_CONNECT_EINPROGRESS
|
201 OBD_CONNECT_JOBSTATS
| OBD_CONNECT_LVB_TYPE
|
202 OBD_CONNECT_LAYOUTLOCK
|
203 OBD_CONNECT_PINGLESS
|
204 OBD_CONNECT_MAX_EASIZE
|
205 OBD_CONNECT_FLOCK_DEAD
|
206 OBD_CONNECT_DISP_STRIPE
;
208 if (sbi
->ll_flags
& LL_SBI_SOM_PREVIEW
)
209 data
->ocd_connect_flags
|= OBD_CONNECT_SOM
;
211 if (sbi
->ll_flags
& LL_SBI_LRU_RESIZE
)
212 data
->ocd_connect_flags
|= OBD_CONNECT_LRU_RESIZE
;
213 #ifdef CONFIG_FS_POSIX_ACL
214 data
->ocd_connect_flags
|= OBD_CONNECT_ACL
| OBD_CONNECT_UMASK
;
217 if (OBD_FAIL_CHECK(OBD_FAIL_MDC_LIGHTWEIGHT
))
218 /* flag mdc connection as lightweight, only used for test
219 * purpose, use with care */
220 data
->ocd_connect_flags
|= OBD_CONNECT_LIGHTWEIGHT
;
222 data
->ocd_ibits_known
= MDS_INODELOCK_FULL
;
223 data
->ocd_version
= LUSTRE_VERSION_CODE
;
225 if (sb
->s_flags
& MS_RDONLY
)
226 data
->ocd_connect_flags
|= OBD_CONNECT_RDONLY
;
227 if (sbi
->ll_flags
& LL_SBI_USER_XATTR
)
228 data
->ocd_connect_flags
|= OBD_CONNECT_XATTR
;
230 #ifdef HAVE_MS_FLOCK_LOCK
231 /* force vfs to use lustre handler for flock() calls - bug 10743 */
232 sb
->s_flags
|= MS_FLOCK_LOCK
;
234 #ifdef MS_HAS_NEW_AOPS
235 sb
->s_flags
|= MS_HAS_NEW_AOPS
;
238 if (sbi
->ll_flags
& LL_SBI_FLOCK
)
239 sbi
->ll_fop
= &ll_file_operations_flock
;
240 else if (sbi
->ll_flags
& LL_SBI_LOCALFLOCK
)
241 sbi
->ll_fop
= &ll_file_operations
;
243 sbi
->ll_fop
= &ll_file_operations_noflock
;
246 data
->ocd_connect_flags
|= OBD_CONNECT_REAL
;
247 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
)
248 data
->ocd_connect_flags
|= OBD_CONNECT_RMT_CLIENT_FORCE
;
250 data
->ocd_brw_size
= MD_MAX_BRW_SIZE
;
252 err
= obd_connect(NULL
, &sbi
->ll_md_exp
, obd
, &sbi
->ll_sb_uuid
, data
, NULL
);
254 LCONSOLE_ERROR_MSG(0x14f, "An MDT (md %s) is performing "
255 "recovery, of which this client is not a "
256 "part. Please wait for recovery to complete,"
257 " abort, or time out.\n", md
);
260 CERROR("cannot connect to %s: rc = %d\n", md
, err
);
264 sbi
->ll_md_exp
->exp_connect_data
= *data
;
266 err
= obd_fid_init(sbi
->ll_md_exp
->exp_obd
, sbi
->ll_md_exp
,
267 LUSTRE_SEQ_METADATA
);
269 CERROR("%s: Can't init metadata layer FID infrastructure, "
270 "rc = %d\n", sbi
->ll_md_exp
->exp_obd
->obd_name
, err
);
274 /* For mount, we only need fs info from MDT0, and also in DNE, it
275 * can make sure the client can be mounted as long as MDT0 is
277 err
= obd_statfs(NULL
, sbi
->ll_md_exp
, osfs
,
278 cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS
),
279 OBD_STATFS_FOR_MDT0
);
281 GOTO(out_md_fid
, err
);
283 /* This needs to be after statfs to ensure connect has finished.
284 * Note that "data" does NOT contain the valid connect reply.
285 * If connecting to a 1.8 server there will be no LMV device, so
286 * we can access the MDC export directly and exp_connect_flags will
287 * be non-zero, but if accessing an upgraded 2.1 server it will
288 * have the correct flags filled in.
289 * XXX: fill in the LMV exp_connect_flags from MDC(s). */
290 valid
= exp_connect_flags(sbi
->ll_md_exp
) & CLIENT_CONNECT_MDT_REQD
;
291 if (exp_connect_flags(sbi
->ll_md_exp
) != 0 &&
292 valid
!= CLIENT_CONNECT_MDT_REQD
) {
295 OBD_ALLOC_WAIT(buf
, PAGE_CACHE_SIZE
);
296 obd_connect_flags2str(buf
, PAGE_CACHE_SIZE
,
297 valid
^ CLIENT_CONNECT_MDT_REQD
, ",");
298 LCONSOLE_ERROR_MSG(0x170, "Server %s does not support "
299 "feature(s) needed for correct operation "
300 "of this client (%s). Please upgrade "
301 "server or downgrade client.\n",
302 sbi
->ll_md_exp
->exp_obd
->obd_name
, buf
);
303 OBD_FREE(buf
, PAGE_CACHE_SIZE
);
304 GOTO(out_md_fid
, err
= -EPROTO
);
307 size
= sizeof(*data
);
308 err
= obd_get_info(NULL
, sbi
->ll_md_exp
, sizeof(KEY_CONN_DATA
),
309 KEY_CONN_DATA
, &size
, data
, NULL
);
311 CERROR("%s: Get connect data failed: rc = %d\n",
312 sbi
->ll_md_exp
->exp_obd
->obd_name
, err
);
313 GOTO(out_md_fid
, err
);
316 LASSERT(osfs
->os_bsize
);
317 sb
->s_blocksize
= osfs
->os_bsize
;
318 sb
->s_blocksize_bits
= log2(osfs
->os_bsize
);
319 sb
->s_magic
= LL_SUPER_MAGIC
;
320 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
321 sbi
->ll_namelen
= osfs
->os_namelen
;
322 sbi
->ll_max_rw_chunk
= LL_DEFAULT_MAX_RW_CHUNK
;
324 if ((sbi
->ll_flags
& LL_SBI_USER_XATTR
) &&
325 !(data
->ocd_connect_flags
& OBD_CONNECT_XATTR
)) {
326 LCONSOLE_INFO("Disabling user_xattr feature because "
327 "it is not supported on the server\n");
328 sbi
->ll_flags
&= ~LL_SBI_USER_XATTR
;
331 if (data
->ocd_connect_flags
& OBD_CONNECT_ACL
) {
333 sb
->s_flags
|= MS_POSIXACL
;
335 sbi
->ll_flags
|= LL_SBI_ACL
;
337 LCONSOLE_INFO("client wants to enable acl, but mdt not!\n");
339 sb
->s_flags
&= ~MS_POSIXACL
;
341 sbi
->ll_flags
&= ~LL_SBI_ACL
;
344 if (data
->ocd_connect_flags
& OBD_CONNECT_RMT_CLIENT
) {
345 if (!(sbi
->ll_flags
& LL_SBI_RMT_CLIENT
)) {
346 sbi
->ll_flags
|= LL_SBI_RMT_CLIENT
;
347 LCONSOLE_INFO("client is set as remote by default.\n");
350 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
) {
351 sbi
->ll_flags
&= ~LL_SBI_RMT_CLIENT
;
352 LCONSOLE_INFO("client claims to be remote, but server "
353 "rejected, forced to be local.\n");
357 if (data
->ocd_connect_flags
& OBD_CONNECT_MDS_CAPA
) {
358 LCONSOLE_INFO("client enabled MDS capability!\n");
359 sbi
->ll_flags
|= LL_SBI_MDS_CAPA
;
362 if (data
->ocd_connect_flags
& OBD_CONNECT_OSS_CAPA
) {
363 LCONSOLE_INFO("client enabled OSS capability!\n");
364 sbi
->ll_flags
|= LL_SBI_OSS_CAPA
;
367 if (data
->ocd_connect_flags
& OBD_CONNECT_64BITHASH
)
368 sbi
->ll_flags
|= LL_SBI_64BIT_HASH
;
370 if (data
->ocd_connect_flags
& OBD_CONNECT_BRW_SIZE
)
371 sbi
->ll_md_brw_size
= data
->ocd_brw_size
;
373 sbi
->ll_md_brw_size
= PAGE_CACHE_SIZE
;
375 if (data
->ocd_connect_flags
& OBD_CONNECT_LAYOUTLOCK
) {
376 LCONSOLE_INFO("Layout lock feature supported.\n");
377 sbi
->ll_flags
|= LL_SBI_LAYOUT_LOCK
;
380 if (data
->ocd_ibits_known
& MDS_INODELOCK_XATTR
) {
381 if (!(data
->ocd_connect_flags
& OBD_CONNECT_MAX_EASIZE
)) {
383 "%s: disabling xattr cache due to unknown maximum xattr size.\n",
386 sbi
->ll_flags
|= LL_SBI_XATTR_CACHE
;
387 sbi
->ll_xattr_cache_enabled
= 1;
391 obd
= class_name2obd(dt
);
393 CERROR("DT %s: not setup or attached\n", dt
);
394 GOTO(out_md_fid
, err
= -ENODEV
);
397 data
->ocd_connect_flags
= OBD_CONNECT_GRANT
| OBD_CONNECT_VERSION
|
398 OBD_CONNECT_REQPORTAL
| OBD_CONNECT_BRW_SIZE
|
399 OBD_CONNECT_CANCELSET
| OBD_CONNECT_FID
|
400 OBD_CONNECT_SRVLOCK
| OBD_CONNECT_TRUNCLOCK
|
401 OBD_CONNECT_AT
| OBD_CONNECT_RMT_CLIENT
|
402 OBD_CONNECT_OSS_CAPA
| OBD_CONNECT_VBR
|
403 OBD_CONNECT_FULL20
| OBD_CONNECT_64BITHASH
|
404 OBD_CONNECT_MAXBYTES
|
405 OBD_CONNECT_EINPROGRESS
|
406 OBD_CONNECT_JOBSTATS
| OBD_CONNECT_LVB_TYPE
|
407 OBD_CONNECT_LAYOUTLOCK
| OBD_CONNECT_PINGLESS
;
409 if (sbi
->ll_flags
& LL_SBI_SOM_PREVIEW
)
410 data
->ocd_connect_flags
|= OBD_CONNECT_SOM
;
412 if (!OBD_FAIL_CHECK(OBD_FAIL_OSC_CONNECT_CKSUM
)) {
413 /* OBD_CONNECT_CKSUM should always be set, even if checksums are
414 * disabled by default, because it can still be enabled on the
415 * fly via /proc. As a consequence, we still need to come to an
416 * agreement on the supported algorithms at connect time */
417 data
->ocd_connect_flags
|= OBD_CONNECT_CKSUM
;
419 if (OBD_FAIL_CHECK(OBD_FAIL_OSC_CKSUM_ADLER_ONLY
))
420 data
->ocd_cksum_types
= OBD_CKSUM_ADLER
;
422 data
->ocd_cksum_types
= cksum_types_supported_client();
425 data
->ocd_connect_flags
|= OBD_CONNECT_LRU_RESIZE
;
426 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
)
427 data
->ocd_connect_flags
|= OBD_CONNECT_RMT_CLIENT_FORCE
;
429 CDEBUG(D_RPCTRACE
, "ocd_connect_flags: "LPX64
" ocd_version: %d "
430 "ocd_grant: %d\n", data
->ocd_connect_flags
,
431 data
->ocd_version
, data
->ocd_grant
);
433 obd
->obd_upcall
.onu_owner
= &sbi
->ll_lco
;
434 obd
->obd_upcall
.onu_upcall
= cl_ocd_update
;
436 data
->ocd_brw_size
= DT_MAX_BRW_SIZE
;
438 err
= obd_connect(NULL
, &sbi
->ll_dt_exp
, obd
, &sbi
->ll_sb_uuid
, data
,
441 LCONSOLE_ERROR_MSG(0x150, "An OST (dt %s) is performing "
442 "recovery, of which this client is not a "
443 "part. Please wait for recovery to "
444 "complete, abort, or time out.\n", dt
);
447 CERROR("%s: Cannot connect to %s: rc = %d\n",
448 sbi
->ll_dt_exp
->exp_obd
->obd_name
, dt
, err
);
452 sbi
->ll_dt_exp
->exp_connect_data
= *data
;
454 err
= obd_fid_init(sbi
->ll_dt_exp
->exp_obd
, sbi
->ll_dt_exp
,
455 LUSTRE_SEQ_METADATA
);
457 CERROR("%s: Can't init data layer FID infrastructure, "
458 "rc = %d\n", sbi
->ll_dt_exp
->exp_obd
->obd_name
, err
);
462 mutex_lock(&sbi
->ll_lco
.lco_lock
);
463 sbi
->ll_lco
.lco_flags
= data
->ocd_connect_flags
;
464 sbi
->ll_lco
.lco_md_exp
= sbi
->ll_md_exp
;
465 sbi
->ll_lco
.lco_dt_exp
= sbi
->ll_dt_exp
;
466 mutex_unlock(&sbi
->ll_lco
.lco_lock
);
468 fid_zero(&sbi
->ll_root_fid
);
469 err
= md_getstatus(sbi
->ll_md_exp
, &sbi
->ll_root_fid
, &oc
);
471 CERROR("cannot mds_connect: rc = %d\n", err
);
472 GOTO(out_lock_cn_cb
, err
);
474 if (!fid_is_sane(&sbi
->ll_root_fid
)) {
475 CERROR("%s: Invalid root fid "DFID
" during mount\n",
476 sbi
->ll_md_exp
->exp_obd
->obd_name
,
477 PFID(&sbi
->ll_root_fid
));
478 GOTO(out_lock_cn_cb
, err
= -EINVAL
);
480 CDEBUG(D_SUPER
, "rootfid "DFID
"\n", PFID(&sbi
->ll_root_fid
));
482 sb
->s_op
= &lustre_super_operations
;
483 #if THREAD_SIZE >= 8192 /*b=17630*/
484 sb
->s_export_op
= &lustre_export_operations
;
488 * XXX: move this to after cbd setup? */
489 valid
= OBD_MD_FLGETATTR
| OBD_MD_FLBLOCKS
| OBD_MD_FLMDSCAPA
;
490 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
)
491 valid
|= OBD_MD_FLRMTPERM
;
492 else if (sbi
->ll_flags
& LL_SBI_ACL
)
493 valid
|= OBD_MD_FLACL
;
495 OBD_ALLOC_PTR(op_data
);
497 GOTO(out_lock_cn_cb
, err
= -ENOMEM
);
499 op_data
->op_fid1
= sbi
->ll_root_fid
;
500 op_data
->op_mode
= 0;
501 op_data
->op_capa1
= oc
;
502 op_data
->op_valid
= valid
;
504 err
= md_getattr(sbi
->ll_md_exp
, op_data
, &request
);
507 OBD_FREE_PTR(op_data
);
509 CERROR("%s: md_getattr failed for root: rc = %d\n",
510 sbi
->ll_md_exp
->exp_obd
->obd_name
, err
);
511 GOTO(out_lock_cn_cb
, err
);
514 err
= md_get_lustre_md(sbi
->ll_md_exp
, request
, sbi
->ll_dt_exp
,
515 sbi
->ll_md_exp
, &lmd
);
517 CERROR("failed to understand root inode md: rc = %d\n", err
);
518 ptlrpc_req_finished(request
);
519 GOTO(out_lock_cn_cb
, err
);
522 LASSERT(fid_is_sane(&sbi
->ll_root_fid
));
523 root
= ll_iget(sb
, cl_fid_build_ino(&sbi
->ll_root_fid
,
524 sbi
->ll_flags
& LL_SBI_32BIT_API
),
526 md_free_lustre_md(sbi
->ll_md_exp
, &lmd
);
527 ptlrpc_req_finished(request
);
529 if (root
== NULL
|| IS_ERR(root
)) {
531 obd_free_memmd(sbi
->ll_dt_exp
, &lmd
.lsm
);
532 #ifdef CONFIG_FS_POSIX_ACL
534 posix_acl_release(lmd
.posix_acl
);
535 lmd
.posix_acl
= NULL
;
538 err
= IS_ERR(root
) ? PTR_ERR(root
) : -EBADF
;
540 CERROR("lustre_lite: bad iget4 for root\n");
544 err
= ll_close_thread_start(&sbi
->ll_lcq
);
546 CERROR("cannot start close thread: rc %d\n", err
);
550 #ifdef CONFIG_FS_POSIX_ACL
551 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
) {
552 rct_init(&sbi
->ll_rct
);
553 et_init(&sbi
->ll_et
);
557 checksum
= sbi
->ll_flags
& LL_SBI_CHECKSUM
;
558 err
= obd_set_info_async(NULL
, sbi
->ll_dt_exp
, sizeof(KEY_CHECKSUM
),
559 KEY_CHECKSUM
, sizeof(checksum
), &checksum
,
563 err
= obd_set_info_async(NULL
, sbi
->ll_dt_exp
, sizeof(KEY_CACHE_SET
),
564 KEY_CACHE_SET
, sizeof(sbi
->ll_cache
),
565 &sbi
->ll_cache
, NULL
);
567 sb
->s_root
= d_make_root(root
);
568 if (sb
->s_root
== NULL
) {
569 CERROR("%s: can't make root dentry\n",
570 ll_get_fsname(sb
, NULL
, 0));
571 GOTO(out_root
, err
= -ENOMEM
);
574 sbi
->ll_sdev_orig
= sb
->s_dev
;
576 /* We set sb->s_dev equal on all lustre clients in order to support
577 * NFS export clustering. NFSD requires that the FSID be the same
579 /* s_dev is also used in lt_compare() to compare two fs, but that is
580 * only a node-local comparison. */
581 uuid
= obd_get_uuid(sbi
->ll_md_exp
);
583 sb
->s_dev
= get_uuid2int(uuid
->uuid
, strlen(uuid
->uuid
));
584 get_uuid2fsid(uuid
->uuid
, strlen(uuid
->uuid
), &sbi
->ll_fsid
);
596 obd_fid_fini(sbi
->ll_dt_exp
->exp_obd
);
598 obd_disconnect(sbi
->ll_dt_exp
);
599 sbi
->ll_dt_exp
= NULL
;
600 /* Make sure all OScs are gone, since cl_cache is accessing sbi. */
601 obd_zombie_barrier();
603 obd_fid_fini(sbi
->ll_md_exp
->exp_obd
);
605 obd_disconnect(sbi
->ll_md_exp
);
606 sbi
->ll_md_exp
= NULL
;
612 lprocfs_unregister_mountpoint(sbi
);
616 int ll_get_max_mdsize(struct ll_sb_info
*sbi
, int *lmmsize
)
620 *lmmsize
= obd_size_diskmd(sbi
->ll_dt_exp
, NULL
);
622 rc
= obd_get_info(NULL
, sbi
->ll_md_exp
, sizeof(KEY_MAX_EASIZE
),
623 KEY_MAX_EASIZE
, &size
, lmmsize
, NULL
);
625 CERROR("Get max mdsize error rc %d \n", rc
);
630 int ll_get_default_mdsize(struct ll_sb_info
*sbi
, int *lmmsize
)
635 rc
= obd_get_info(NULL
, sbi
->ll_md_exp
, sizeof(KEY_DEFAULT_EASIZE
),
636 KEY_DEFAULT_EASIZE
, &size
, lmmsize
, NULL
);
638 CERROR("Get default mdsize error rc %d\n", rc
);
643 int ll_get_max_cookiesize(struct ll_sb_info
*sbi
, int *lmmsize
)
648 rc
= obd_get_info(NULL
, sbi
->ll_md_exp
, sizeof(KEY_MAX_COOKIESIZE
),
649 KEY_MAX_COOKIESIZE
, &size
, lmmsize
, NULL
);
651 CERROR("Get max cookiesize error rc %d\n", rc
);
656 int ll_get_default_cookiesize(struct ll_sb_info
*sbi
, int *lmmsize
)
661 rc
= obd_get_info(NULL
, sbi
->ll_md_exp
, sizeof(KEY_DEFAULT_COOKIESIZE
),
662 KEY_DEFAULT_COOKIESIZE
, &size
, lmmsize
, NULL
);
664 CERROR("Get default cookiesize error rc %d\n", rc
);
669 static void ll_dump_inode(struct inode
*inode
)
671 struct ll_d_hlist_node
*tmp
;
672 int dentry_count
= 0;
674 LASSERT(inode
!= NULL
);
676 ll_d_hlist_for_each(tmp
, &inode
->i_dentry
)
679 CERROR("inode %p dump: dev=%s ino=%lu mode=%o count=%u, %d dentries\n",
680 inode
, ll_i2mdexp(inode
)->exp_obd
->obd_name
, inode
->i_ino
,
681 inode
->i_mode
, atomic_read(&inode
->i_count
), dentry_count
);
684 void lustre_dump_dentry(struct dentry
*dentry
, int recur
)
686 struct list_head
*tmp
;
689 LASSERT(dentry
!= NULL
);
691 list_for_each(tmp
, &dentry
->d_subdirs
)
694 CERROR("dentry %p dump: name=%.*s parent=%.*s (%p), inode=%p, count=%u,"
695 " flags=0x%x, fsdata=%p, %d subdirs\n", dentry
,
696 dentry
->d_name
.len
, dentry
->d_name
.name
,
697 dentry
->d_parent
->d_name
.len
, dentry
->d_parent
->d_name
.name
,
698 dentry
->d_parent
, dentry
->d_inode
, d_count(dentry
),
699 dentry
->d_flags
, dentry
->d_fsdata
, subdirs
);
700 if (dentry
->d_inode
!= NULL
)
701 ll_dump_inode(dentry
->d_inode
);
706 list_for_each(tmp
, &dentry
->d_subdirs
) {
707 struct dentry
*d
= list_entry(tmp
, struct dentry
, d_u
.d_child
);
708 lustre_dump_dentry(d
, recur
- 1);
712 static void client_common_put_super(struct super_block
*sb
)
714 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
716 #ifdef CONFIG_FS_POSIX_ACL
717 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
) {
718 et_fini(&sbi
->ll_et
);
719 rct_fini(&sbi
->ll_rct
);
723 ll_close_thread_shutdown(sbi
->ll_lcq
);
727 list_del(&sbi
->ll_conn_chain
);
729 obd_fid_fini(sbi
->ll_dt_exp
->exp_obd
);
730 obd_disconnect(sbi
->ll_dt_exp
);
731 sbi
->ll_dt_exp
= NULL
;
732 /* wait till all OSCs are gone, since cl_cache is accessing sbi.
734 obd_zombie_barrier();
736 lprocfs_unregister_mountpoint(sbi
);
738 obd_fid_fini(sbi
->ll_md_exp
->exp_obd
);
739 obd_disconnect(sbi
->ll_md_exp
);
740 sbi
->ll_md_exp
= NULL
;
743 void ll_kill_super(struct super_block
*sb
)
745 struct ll_sb_info
*sbi
;
748 if (!(sb
->s_flags
& MS_ACTIVE
))
752 /* we need to restore s_dev from changed for clustered NFS before put_super
753 * because new kernels have cached s_dev and change sb->s_dev in
754 * put_super not affected real removing devices */
756 sb
->s_dev
= sbi
->ll_sdev_orig
;
757 sbi
->ll_umounting
= 1;
761 static inline int ll_set_opt(const char *opt
, char *data
, int fl
)
763 if (strncmp(opt
, data
, strlen(opt
)) != 0)
769 /* non-client-specific mount options are parsed in lmd_parse */
770 static int ll_options(char *options
, int *flags
)
773 char *s1
= options
, *s2
;
778 CDEBUG(D_CONFIG
, "Parsing opts %s\n", options
);
781 CDEBUG(D_SUPER
, "next opt=%s\n", s1
);
782 tmp
= ll_set_opt("nolock", s1
, LL_SBI_NOLCK
);
787 tmp
= ll_set_opt("flock", s1
, LL_SBI_FLOCK
);
792 tmp
= ll_set_opt("localflock", s1
, LL_SBI_LOCALFLOCK
);
797 tmp
= ll_set_opt("noflock", s1
, LL_SBI_FLOCK
|LL_SBI_LOCALFLOCK
);
802 tmp
= ll_set_opt("user_xattr", s1
, LL_SBI_USER_XATTR
);
807 tmp
= ll_set_opt("nouser_xattr", s1
, LL_SBI_USER_XATTR
);
812 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 5, 50, 0)
813 tmp
= ll_set_opt("acl", s1
, LL_SBI_ACL
);
815 /* Ignore deprecated mount option. The client will
816 * always try to mount with ACL support, whether this
817 * is used depends on whether server supports it. */
818 LCONSOLE_ERROR_MSG(0x152, "Ignoring deprecated "
819 "mount option 'acl'.\n");
822 tmp
= ll_set_opt("noacl", s1
, LL_SBI_ACL
);
824 LCONSOLE_ERROR_MSG(0x152, "Ignoring deprecated "
825 "mount option 'noacl'.\n");
829 #warning "{no}acl options have been deprecated since 1.8, please remove them"
831 tmp
= ll_set_opt("remote_client", s1
, LL_SBI_RMT_CLIENT
);
836 tmp
= ll_set_opt("user_fid2path", s1
, LL_SBI_USER_FID2PATH
);
841 tmp
= ll_set_opt("nouser_fid2path", s1
, LL_SBI_USER_FID2PATH
);
847 tmp
= ll_set_opt("checksum", s1
, LL_SBI_CHECKSUM
);
852 tmp
= ll_set_opt("nochecksum", s1
, LL_SBI_CHECKSUM
);
857 tmp
= ll_set_opt("lruresize", s1
, LL_SBI_LRU_RESIZE
);
862 tmp
= ll_set_opt("nolruresize", s1
, LL_SBI_LRU_RESIZE
);
867 tmp
= ll_set_opt("lazystatfs", s1
, LL_SBI_LAZYSTATFS
);
872 tmp
= ll_set_opt("nolazystatfs", s1
, LL_SBI_LAZYSTATFS
);
877 tmp
= ll_set_opt("som_preview", s1
, LL_SBI_SOM_PREVIEW
);
882 tmp
= ll_set_opt("32bitapi", s1
, LL_SBI_32BIT_API
);
887 tmp
= ll_set_opt("verbose", s1
, LL_SBI_VERBOSE
);
892 tmp
= ll_set_opt("noverbose", s1
, LL_SBI_VERBOSE
);
897 LCONSOLE_ERROR_MSG(0x152, "Unknown option '%s', won't mount.\n",
903 s2
= strchr(s1
, ',');
911 void ll_lli_init(struct ll_inode_info
*lli
)
913 lli
->lli_inode_magic
= LLI_INODE_MAGIC
;
915 lli
->lli_ioepoch
= 0;
916 lli
->lli_maxbytes
= MAX_LFS_FILESIZE
;
917 spin_lock_init(&lli
->lli_lock
);
918 lli
->lli_posix_acl
= NULL
;
919 lli
->lli_remote_perms
= NULL
;
920 mutex_init(&lli
->lli_rmtperm_mutex
);
921 /* Do not set lli_fid, it has been initialized already. */
922 fid_zero(&lli
->lli_pfid
);
923 INIT_LIST_HEAD(&lli
->lli_close_list
);
924 INIT_LIST_HEAD(&lli
->lli_oss_capas
);
925 atomic_set(&lli
->lli_open_count
, 0);
926 lli
->lli_mds_capa
= NULL
;
927 lli
->lli_rmtperm_time
= 0;
928 lli
->lli_pending_och
= NULL
;
929 lli
->lli_mds_read_och
= NULL
;
930 lli
->lli_mds_write_och
= NULL
;
931 lli
->lli_mds_exec_och
= NULL
;
932 lli
->lli_open_fd_read_count
= 0;
933 lli
->lli_open_fd_write_count
= 0;
934 lli
->lli_open_fd_exec_count
= 0;
935 mutex_init(&lli
->lli_och_mutex
);
936 spin_lock_init(&lli
->lli_agl_lock
);
937 lli
->lli_has_smd
= false;
938 spin_lock_init(&lli
->lli_layout_lock
);
939 ll_layout_version_set(lli
, LL_LAYOUT_GEN_NONE
);
940 lli
->lli_clob
= NULL
;
942 init_rwsem(&lli
->lli_xattrs_list_rwsem
);
943 mutex_init(&lli
->lli_xattrs_enq_lock
);
945 LASSERT(lli
->lli_vfs_inode
.i_mode
!= 0);
946 if (S_ISDIR(lli
->lli_vfs_inode
.i_mode
)) {
947 mutex_init(&lli
->lli_readdir_mutex
);
948 lli
->lli_opendir_key
= NULL
;
950 spin_lock_init(&lli
->lli_sa_lock
);
951 lli
->lli_opendir_pid
= 0;
953 mutex_init(&lli
->lli_size_mutex
);
954 lli
->lli_symlink_name
= NULL
;
955 init_rwsem(&lli
->lli_trunc_sem
);
956 mutex_init(&lli
->lli_write_mutex
);
957 init_rwsem(&lli
->lli_glimpse_sem
);
958 lli
->lli_glimpse_time
= 0;
959 INIT_LIST_HEAD(&lli
->lli_agl_list
);
960 lli
->lli_agl_index
= 0;
961 lli
->lli_async_rc
= 0;
963 mutex_init(&lli
->lli_layout_mutex
);
966 static inline int ll_bdi_register(struct backing_dev_info
*bdi
)
968 static atomic_t ll_bdi_num
= ATOMIC_INIT(0);
970 bdi
->name
= "lustre";
971 return bdi_register(bdi
, NULL
, "lustre-%d",
972 atomic_inc_return(&ll_bdi_num
));
975 int ll_fill_super(struct super_block
*sb
, struct vfsmount
*mnt
)
977 struct lustre_profile
*lprof
= NULL
;
978 struct lustre_sb_info
*lsi
= s2lsi(sb
);
979 struct ll_sb_info
*sbi
;
980 char *dt
= NULL
, *md
= NULL
;
981 char *profilenm
= get_profile_name(sb
);
982 struct config_llog_instance
*cfg
;
983 /* %p for void* in printf needs 16+2 characters: 0xffffffffffffffff */
984 const int instlen
= sizeof(cfg
->cfg_instance
) * 2 + 2;
987 CDEBUG(D_VFSTRACE
, "VFS Op: sb %p\n", sb
);
993 try_module_get(THIS_MODULE
);
995 /* client additional sb info */
996 lsi
->lsi_llsbi
= sbi
= ll_init_sbi();
998 module_put(THIS_MODULE
);
1003 err
= ll_options(lsi
->lsi_lmd
->lmd_opts
, &sbi
->ll_flags
);
1005 GOTO(out_free
, err
);
1007 err
= bdi_init(&lsi
->lsi_bdi
);
1009 GOTO(out_free
, err
);
1010 lsi
->lsi_flags
|= LSI_BDI_INITIALIZED
;
1011 lsi
->lsi_bdi
.capabilities
= BDI_CAP_MAP_COPY
;
1012 err
= ll_bdi_register(&lsi
->lsi_bdi
);
1014 GOTO(out_free
, err
);
1016 sb
->s_bdi
= &lsi
->lsi_bdi
;
1017 /* kernel >= 2.6.38 store dentry operations in sb->s_d_op. */
1018 sb
->s_d_op
= &ll_d_ops
;
1020 /* Generate a string unique to this super, in case some joker tries
1021 to mount the same fs at two mount points.
1022 Use the address of the super itself.*/
1023 cfg
->cfg_instance
= sb
;
1024 cfg
->cfg_uuid
= lsi
->lsi_llsbi
->ll_sb_uuid
;
1025 cfg
->cfg_callback
= class_config_llog_handler
;
1026 /* set up client obds */
1027 err
= lustre_process_log(sb
, profilenm
, cfg
);
1029 CERROR("Unable to process log: %d\n", err
);
1030 GOTO(out_free
, err
);
1033 /* Profile set with LCFG_MOUNTOPT so we can find our mdc and osc obds */
1034 lprof
= class_get_profile(profilenm
);
1035 if (lprof
== NULL
) {
1036 LCONSOLE_ERROR_MSG(0x156, "The client profile '%s' could not be"
1037 " read from the MGS. Does that filesystem "
1038 "exist?\n", profilenm
);
1039 GOTO(out_free
, err
= -EINVAL
);
1041 CDEBUG(D_CONFIG
, "Found profile %s: mdc=%s osc=%s\n", profilenm
,
1042 lprof
->lp_md
, lprof
->lp_dt
);
1044 OBD_ALLOC(dt
, strlen(lprof
->lp_dt
) + instlen
+ 2);
1046 GOTO(out_free
, err
= -ENOMEM
);
1047 sprintf(dt
, "%s-%p", lprof
->lp_dt
, cfg
->cfg_instance
);
1049 OBD_ALLOC(md
, strlen(lprof
->lp_md
) + instlen
+ 2);
1051 GOTO(out_free
, err
= -ENOMEM
);
1052 sprintf(md
, "%s-%p", lprof
->lp_md
, cfg
->cfg_instance
);
1054 /* connections, registrations, sb setup */
1055 err
= client_common_fill_super(sb
, md
, dt
, mnt
);
1059 OBD_FREE(md
, strlen(lprof
->lp_md
) + instlen
+ 2);
1061 OBD_FREE(dt
, strlen(lprof
->lp_dt
) + instlen
+ 2);
1064 else if (sbi
->ll_flags
& LL_SBI_VERBOSE
)
1065 LCONSOLE_WARN("Mounted %s\n", profilenm
);
1069 } /* ll_fill_super */
1071 void ll_put_super(struct super_block
*sb
)
1073 struct config_llog_instance cfg
, params_cfg
;
1074 struct obd_device
*obd
;
1075 struct lustre_sb_info
*lsi
= s2lsi(sb
);
1076 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
1077 char *profilenm
= get_profile_name(sb
);
1078 int next
, force
= 1;
1080 CDEBUG(D_VFSTRACE
, "VFS Op: sb %p - %s\n", sb
, profilenm
);
1082 ll_print_capa_stat(sbi
);
1084 cfg
.cfg_instance
= sb
;
1085 lustre_end_log(sb
, profilenm
, &cfg
);
1087 params_cfg
.cfg_instance
= sb
;
1088 lustre_end_log(sb
, PARAMS_FILENAME
, ¶ms_cfg
);
1090 if (sbi
->ll_md_exp
) {
1091 obd
= class_exp2obd(sbi
->ll_md_exp
);
1093 force
= obd
->obd_force
;
1096 /* We need to set force before the lov_disconnect in
1097 lustre_common_put_super, since l_d cleans up osc's as well. */
1100 while ((obd
= class_devices_in_group(&sbi
->ll_sb_uuid
,
1102 obd
->obd_force
= force
;
1107 /* Only if client_common_fill_super succeeded */
1108 client_common_put_super(sb
);
1112 while ((obd
= class_devices_in_group(&sbi
->ll_sb_uuid
, &next
)) !=NULL
) {
1113 class_manual_cleanup(obd
);
1116 if (sbi
->ll_flags
& LL_SBI_VERBOSE
)
1117 LCONSOLE_WARN("Unmounted %s\n", profilenm
? profilenm
: "");
1120 class_del_profile(profilenm
);
1122 if (lsi
->lsi_flags
& LSI_BDI_INITIALIZED
) {
1123 bdi_destroy(&lsi
->lsi_bdi
);
1124 lsi
->lsi_flags
&= ~LSI_BDI_INITIALIZED
;
1128 lsi
->lsi_llsbi
= NULL
;
1130 lustre_common_put_super(sb
);
1132 module_put(THIS_MODULE
);
1133 } /* client_put_super */
1135 struct inode
*ll_inode_from_resource_lock(struct ldlm_lock
*lock
)
1137 struct inode
*inode
= NULL
;
1139 /* NOTE: we depend on atomic igrab() -bzzz */
1140 lock_res_and_lock(lock
);
1141 if (lock
->l_resource
->lr_lvb_inode
) {
1142 struct ll_inode_info
* lli
;
1143 lli
= ll_i2info(lock
->l_resource
->lr_lvb_inode
);
1144 if (lli
->lli_inode_magic
== LLI_INODE_MAGIC
) {
1145 inode
= igrab(lock
->l_resource
->lr_lvb_inode
);
1147 inode
= lock
->l_resource
->lr_lvb_inode
;
1148 LDLM_DEBUG_LIMIT(inode
->i_state
& I_FREEING
? D_INFO
:
1149 D_WARNING
, lock
, "lr_lvb_inode %p is "
1150 "bogus: magic %08x",
1151 lock
->l_resource
->lr_lvb_inode
,
1152 lli
->lli_inode_magic
);
1156 unlock_res_and_lock(lock
);
1160 void ll_clear_inode(struct inode
*inode
)
1162 struct ll_inode_info
*lli
= ll_i2info(inode
);
1163 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
1165 CDEBUG(D_VFSTRACE
, "VFS Op:inode=%lu/%u(%p)\n", inode
->i_ino
,
1166 inode
->i_generation
, inode
);
1168 if (S_ISDIR(inode
->i_mode
)) {
1169 /* these should have been cleared in ll_file_release */
1170 LASSERT(lli
->lli_opendir_key
== NULL
);
1171 LASSERT(lli
->lli_sai
== NULL
);
1172 LASSERT(lli
->lli_opendir_pid
== 0);
1175 spin_lock(&lli
->lli_lock
);
1176 ll_i2info(inode
)->lli_flags
&= ~LLIF_MDS_SIZE_LOCK
;
1177 spin_unlock(&lli
->lli_lock
);
1178 md_null_inode(sbi
->ll_md_exp
, ll_inode2fid(inode
));
1180 LASSERT(!lli
->lli_open_fd_write_count
);
1181 LASSERT(!lli
->lli_open_fd_read_count
);
1182 LASSERT(!lli
->lli_open_fd_exec_count
);
1184 if (lli
->lli_mds_write_och
)
1185 ll_md_real_close(inode
, FMODE_WRITE
);
1186 if (lli
->lli_mds_exec_och
)
1187 ll_md_real_close(inode
, FMODE_EXEC
);
1188 if (lli
->lli_mds_read_och
)
1189 ll_md_real_close(inode
, FMODE_READ
);
1191 if (S_ISLNK(inode
->i_mode
) && lli
->lli_symlink_name
) {
1192 OBD_FREE(lli
->lli_symlink_name
,
1193 strlen(lli
->lli_symlink_name
) + 1);
1194 lli
->lli_symlink_name
= NULL
;
1197 ll_xattr_cache_destroy(inode
);
1199 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
) {
1200 LASSERT(lli
->lli_posix_acl
== NULL
);
1201 if (lli
->lli_remote_perms
) {
1202 free_rmtperm_hash(lli
->lli_remote_perms
);
1203 lli
->lli_remote_perms
= NULL
;
1206 #ifdef CONFIG_FS_POSIX_ACL
1207 else if (lli
->lli_posix_acl
) {
1208 LASSERT(atomic_read(&lli
->lli_posix_acl
->a_refcount
) == 1);
1209 LASSERT(lli
->lli_remote_perms
== NULL
);
1210 posix_acl_release(lli
->lli_posix_acl
);
1211 lli
->lli_posix_acl
= NULL
;
1214 lli
->lli_inode_magic
= LLI_INODE_DEAD
;
1216 ll_clear_inode_capas(inode
);
1217 if (!S_ISDIR(inode
->i_mode
))
1218 LASSERT(list_empty(&lli
->lli_agl_list
));
1221 * XXX This has to be done before lsm is freed below, because
1222 * cl_object still uses inode lsm.
1224 cl_inode_fini(inode
);
1225 lli
->lli_has_smd
= false;
1228 int ll_md_setattr(struct dentry
*dentry
, struct md_op_data
*op_data
,
1229 struct md_open_data
**mod
)
1231 struct lustre_md md
;
1232 struct inode
*inode
= dentry
->d_inode
;
1233 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
1234 struct ptlrpc_request
*request
= NULL
;
1237 op_data
= ll_prep_md_op_data(op_data
, inode
, NULL
, NULL
, 0, 0,
1238 LUSTRE_OPC_ANY
, NULL
);
1239 if (IS_ERR(op_data
))
1240 return PTR_ERR(op_data
);
1242 rc
= md_setattr(sbi
->ll_md_exp
, op_data
, NULL
, 0, NULL
, 0,
1245 ptlrpc_req_finished(request
);
1246 if (rc
== -ENOENT
) {
1248 /* Unlinked special device node? Or just a race?
1249 * Pretend we done everything. */
1250 if (!S_ISREG(inode
->i_mode
) &&
1251 !S_ISDIR(inode
->i_mode
)) {
1252 ia_valid
= op_data
->op_attr
.ia_valid
;
1253 op_data
->op_attr
.ia_valid
&= ~TIMES_SET_FLAGS
;
1254 rc
= simple_setattr(dentry
, &op_data
->op_attr
);
1255 op_data
->op_attr
.ia_valid
= ia_valid
;
1257 } else if (rc
!= -EPERM
&& rc
!= -EACCES
&& rc
!= -ETXTBSY
) {
1258 CERROR("md_setattr fails: rc = %d\n", rc
);
1263 rc
= md_get_lustre_md(sbi
->ll_md_exp
, request
, sbi
->ll_dt_exp
,
1264 sbi
->ll_md_exp
, &md
);
1266 ptlrpc_req_finished(request
);
1270 ia_valid
= op_data
->op_attr
.ia_valid
;
1271 /* inode size will be in ll_setattr_ost, can't do it now since dirty
1272 * cache is not cleared yet. */
1273 op_data
->op_attr
.ia_valid
&= ~(TIMES_SET_FLAGS
| ATTR_SIZE
);
1274 rc
= simple_setattr(dentry
, &op_data
->op_attr
);
1275 op_data
->op_attr
.ia_valid
= ia_valid
;
1277 /* Extract epoch data if obtained. */
1278 op_data
->op_handle
= md
.body
->handle
;
1279 op_data
->op_ioepoch
= md
.body
->ioepoch
;
1281 ll_update_inode(inode
, &md
);
1282 ptlrpc_req_finished(request
);
1287 /* Close IO epoch and send Size-on-MDS attribute update. */
1288 static int ll_setattr_done_writing(struct inode
*inode
,
1289 struct md_op_data
*op_data
,
1290 struct md_open_data
*mod
)
1292 struct ll_inode_info
*lli
= ll_i2info(inode
);
1295 LASSERT(op_data
!= NULL
);
1296 if (!S_ISREG(inode
->i_mode
))
1299 CDEBUG(D_INODE
, "Epoch "LPU64
" closed on "DFID
" for truncate\n",
1300 op_data
->op_ioepoch
, PFID(&lli
->lli_fid
));
1302 op_data
->op_flags
= MF_EPOCH_CLOSE
;
1303 ll_done_writing_attr(inode
, op_data
);
1304 ll_pack_inode2opdata(inode
, op_data
, NULL
);
1306 rc
= md_done_writing(ll_i2sbi(inode
)->ll_md_exp
, op_data
, mod
);
1307 if (rc
== -EAGAIN
) {
1308 /* MDS has instructed us to obtain Size-on-MDS attribute
1309 * from OSTs and send setattr to back to MDS. */
1310 rc
= ll_som_update(inode
, op_data
);
1312 CERROR("inode %lu mdc truncate failed: rc = %d\n",
1318 static int ll_setattr_ost(struct inode
*inode
, struct iattr
*attr
)
1320 struct obd_capa
*capa
;
1323 if (attr
->ia_valid
& ATTR_SIZE
)
1324 capa
= ll_osscapa_get(inode
, CAPA_OPC_OSS_TRUNC
);
1326 capa
= ll_mdscapa_get(inode
);
1328 rc
= cl_setattr_ost(inode
, attr
, capa
);
1330 if (attr
->ia_valid
& ATTR_SIZE
)
1331 ll_truncate_free_capa(capa
);
1339 /* If this inode has objects allocated to it (lsm != NULL), then the OST
1340 * object(s) determine the file size and mtime. Otherwise, the MDS will
1341 * keep these values until such a time that objects are allocated for it.
1342 * We do the MDS operations first, as it is checking permissions for us.
1343 * We don't to the MDS RPC if there is nothing that we want to store there,
1344 * otherwise there is no harm in updating mtime/atime on the MDS if we are
1345 * going to do an RPC anyways.
1347 * If we are doing a truncate, we will send the mtime and ctime updates
1348 * to the OST with the punch RPC, otherwise we do an explicit setattr RPC.
1349 * I don't believe it is possible to get e.g. ATTR_MTIME_SET and ATTR_SIZE
1352 * In case of HSMimport, we only set attr on MDS.
1354 int ll_setattr_raw(struct dentry
*dentry
, struct iattr
*attr
, bool hsm_import
)
1356 struct inode
*inode
= dentry
->d_inode
;
1357 struct ll_inode_info
*lli
= ll_i2info(inode
);
1358 struct md_op_data
*op_data
= NULL
;
1359 struct md_open_data
*mod
= NULL
;
1360 bool file_is_released
= false;
1361 int rc
= 0, rc1
= 0;
1364 "%s: setattr inode %p/fid:"DFID
1365 " from %llu to %llu, valid %x, hsm_import %d\n",
1366 ll_get_fsname(inode
->i_sb
, NULL
, 0), inode
,
1367 PFID(&lli
->lli_fid
), i_size_read(inode
), attr
->ia_size
,
1368 attr
->ia_valid
, hsm_import
);
1370 if (attr
->ia_valid
& ATTR_SIZE
) {
1371 /* Check new size against VFS/VM file size limit and rlimit */
1372 rc
= inode_newsize_ok(inode
, attr
->ia_size
);
1376 /* The maximum Lustre file size is variable, based on the
1377 * OST maximum object size and number of stripes. This
1378 * needs another check in addition to the VFS check above. */
1379 if (attr
->ia_size
> ll_file_maxbytes(inode
)) {
1380 CDEBUG(D_INODE
,"file "DFID
" too large %llu > "LPU64
"\n",
1381 PFID(&lli
->lli_fid
), attr
->ia_size
,
1382 ll_file_maxbytes(inode
));
1386 attr
->ia_valid
|= ATTR_MTIME
| ATTR_CTIME
;
1389 /* POSIX: check before ATTR_*TIME_SET set (from inode_change_ok) */
1390 if (attr
->ia_valid
& TIMES_SET_FLAGS
) {
1391 if ((!uid_eq(current_fsuid(), inode
->i_uid
)) &&
1392 !capable(CFS_CAP_FOWNER
))
1396 /* We mark all of the fields "set" so MDS/OST does not re-set them */
1397 if (attr
->ia_valid
& ATTR_CTIME
) {
1398 attr
->ia_ctime
= CURRENT_TIME
;
1399 attr
->ia_valid
|= ATTR_CTIME_SET
;
1401 if (!(attr
->ia_valid
& ATTR_ATIME_SET
) &&
1402 (attr
->ia_valid
& ATTR_ATIME
)) {
1403 attr
->ia_atime
= CURRENT_TIME
;
1404 attr
->ia_valid
|= ATTR_ATIME_SET
;
1406 if (!(attr
->ia_valid
& ATTR_MTIME_SET
) &&
1407 (attr
->ia_valid
& ATTR_MTIME
)) {
1408 attr
->ia_mtime
= CURRENT_TIME
;
1409 attr
->ia_valid
|= ATTR_MTIME_SET
;
1412 if (attr
->ia_valid
& (ATTR_MTIME
| ATTR_CTIME
))
1413 CDEBUG(D_INODE
, "setting mtime %lu, ctime %lu, now = %lu\n",
1414 LTIME_S(attr
->ia_mtime
), LTIME_S(attr
->ia_ctime
),
1415 cfs_time_current_sec());
1417 /* If we are changing file size, file content is modified, flag it. */
1418 if (attr
->ia_valid
& ATTR_SIZE
) {
1419 attr
->ia_valid
|= MDS_OPEN_OWNEROVERRIDE
;
1420 spin_lock(&lli
->lli_lock
);
1421 lli
->lli_flags
|= LLIF_DATA_MODIFIED
;
1422 spin_unlock(&lli
->lli_lock
);
1425 /* We always do an MDS RPC, even if we're only changing the size;
1426 * only the MDS knows whether truncate() should fail with -ETXTBUSY */
1428 OBD_ALLOC_PTR(op_data
);
1429 if (op_data
== NULL
)
1432 if (!S_ISDIR(inode
->i_mode
)) {
1433 if (attr
->ia_valid
& ATTR_SIZE
)
1434 inode_dio_write_done(inode
);
1435 mutex_unlock(&inode
->i_mutex
);
1438 memcpy(&op_data
->op_attr
, attr
, sizeof(*attr
));
1440 /* Open epoch for truncate. */
1441 if (exp_connect_som(ll_i2mdexp(inode
)) &&
1442 (attr
->ia_valid
& (ATTR_SIZE
| ATTR_MTIME
| ATTR_MTIME_SET
)))
1443 op_data
->op_flags
= MF_EPOCH_OPEN
;
1445 /* truncate on a released file must failed with -ENODATA,
1446 * so size must not be set on MDS for released file
1447 * but other attributes must be set
1449 if (S_ISREG(inode
->i_mode
)) {
1450 struct lov_stripe_md
*lsm
;
1453 ll_layout_refresh(inode
, &gen
);
1454 lsm
= ccc_inode_lsm_get(inode
);
1455 if (lsm
&& lsm
->lsm_pattern
& LOV_PATTERN_F_RELEASED
)
1456 file_is_released
= true;
1457 ccc_inode_lsm_put(inode
, lsm
);
1460 /* if not in HSM import mode, clear size attr for released file
1461 * we clear the attribute send to MDT in op_data, not the original
1462 * received from caller in attr which is used later to
1463 * decide return code */
1464 if (file_is_released
&& (attr
->ia_valid
& ATTR_SIZE
) && !hsm_import
)
1465 op_data
->op_attr
.ia_valid
&= ~ATTR_SIZE
;
1467 rc
= ll_md_setattr(dentry
, op_data
, &mod
);
1471 /* truncate failed (only when non HSM import), others succeed */
1472 if (file_is_released
) {
1473 if ((attr
->ia_valid
& ATTR_SIZE
) && !hsm_import
)
1474 GOTO(out
, rc
= -ENODATA
);
1479 /* RPC to MDT is sent, cancel data modification flag */
1480 if (rc
== 0 && (op_data
->op_bias
& MDS_DATA_MODIFIED
)) {
1481 spin_lock(&lli
->lli_lock
);
1482 lli
->lli_flags
&= ~LLIF_DATA_MODIFIED
;
1483 spin_unlock(&lli
->lli_lock
);
1486 ll_ioepoch_open(lli
, op_data
->op_ioepoch
);
1487 if (!S_ISREG(inode
->i_mode
))
1490 if (attr
->ia_valid
& (ATTR_SIZE
|
1491 ATTR_ATIME
| ATTR_ATIME_SET
|
1492 ATTR_MTIME
| ATTR_MTIME_SET
))
1493 /* For truncate and utimes sending attributes to OSTs, setting
1494 * mtime/atime to the past will be performed under PW [0:EOF]
1495 * extent lock (new_size:EOF for truncate). It may seem
1496 * excessive to send mtime/atime updates to OSTs when not
1497 * setting times to past, but it is necessary due to possible
1498 * time de-synchronization between MDT inode and OST objects */
1499 if (attr
->ia_valid
& ATTR_SIZE
)
1500 down_write(&lli
->lli_trunc_sem
);
1501 rc
= ll_setattr_ost(inode
, attr
);
1502 if (attr
->ia_valid
& ATTR_SIZE
)
1503 up_write(&lli
->lli_trunc_sem
);
1506 if (op_data
->op_ioepoch
) {
1507 rc1
= ll_setattr_done_writing(inode
, op_data
, mod
);
1511 ll_finish_md_op_data(op_data
);
1513 if (!S_ISDIR(inode
->i_mode
)) {
1514 mutex_lock(&inode
->i_mutex
);
1515 if ((attr
->ia_valid
& ATTR_SIZE
) && !hsm_import
)
1516 inode_dio_wait(inode
);
1519 ll_stats_ops_tally(ll_i2sbi(inode
), (attr
->ia_valid
& ATTR_SIZE
) ?
1520 LPROC_LL_TRUNC
: LPROC_LL_SETATTR
, 1);
1525 int ll_setattr(struct dentry
*de
, struct iattr
*attr
)
1527 int mode
= de
->d_inode
->i_mode
;
1529 if ((attr
->ia_valid
& (ATTR_CTIME
|ATTR_SIZE
|ATTR_MODE
)) ==
1530 (ATTR_CTIME
|ATTR_SIZE
|ATTR_MODE
))
1531 attr
->ia_valid
|= MDS_OPEN_OWNEROVERRIDE
;
1533 if (((attr
->ia_valid
& (ATTR_MODE
|ATTR_FORCE
|ATTR_SIZE
)) ==
1534 (ATTR_SIZE
|ATTR_MODE
)) &&
1535 (((mode
& S_ISUID
) && !(attr
->ia_mode
& S_ISUID
)) ||
1536 (((mode
& (S_ISGID
|S_IXGRP
)) == (S_ISGID
|S_IXGRP
)) &&
1537 !(attr
->ia_mode
& S_ISGID
))))
1538 attr
->ia_valid
|= ATTR_FORCE
;
1540 if ((attr
->ia_valid
& ATTR_MODE
) &&
1542 !(attr
->ia_mode
& S_ISUID
) &&
1543 !(attr
->ia_valid
& ATTR_KILL_SUID
))
1544 attr
->ia_valid
|= ATTR_KILL_SUID
;
1546 if ((attr
->ia_valid
& ATTR_MODE
) &&
1547 ((mode
& (S_ISGID
|S_IXGRP
)) == (S_ISGID
|S_IXGRP
)) &&
1548 !(attr
->ia_mode
& S_ISGID
) &&
1549 !(attr
->ia_valid
& ATTR_KILL_SGID
))
1550 attr
->ia_valid
|= ATTR_KILL_SGID
;
1552 return ll_setattr_raw(de
, attr
, false);
1555 int ll_statfs_internal(struct super_block
*sb
, struct obd_statfs
*osfs
,
1556 __u64 max_age
, __u32 flags
)
1558 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
1559 struct obd_statfs obd_osfs
;
1562 rc
= obd_statfs(NULL
, sbi
->ll_md_exp
, osfs
, max_age
, flags
);
1564 CERROR("md_statfs fails: rc = %d\n", rc
);
1568 osfs
->os_type
= sb
->s_magic
;
1570 CDEBUG(D_SUPER
, "MDC blocks "LPU64
"/"LPU64
" objects "LPU64
"/"LPU64
"\n",
1571 osfs
->os_bavail
, osfs
->os_blocks
, osfs
->os_ffree
,osfs
->os_files
);
1573 if (sbi
->ll_flags
& LL_SBI_LAZYSTATFS
)
1574 flags
|= OBD_STATFS_NODELAY
;
1576 rc
= obd_statfs_rqset(sbi
->ll_dt_exp
, &obd_osfs
, max_age
, flags
);
1578 CERROR("obd_statfs fails: rc = %d\n", rc
);
1582 CDEBUG(D_SUPER
, "OSC blocks "LPU64
"/"LPU64
" objects "LPU64
"/"LPU64
"\n",
1583 obd_osfs
.os_bavail
, obd_osfs
.os_blocks
, obd_osfs
.os_ffree
,
1586 osfs
->os_bsize
= obd_osfs
.os_bsize
;
1587 osfs
->os_blocks
= obd_osfs
.os_blocks
;
1588 osfs
->os_bfree
= obd_osfs
.os_bfree
;
1589 osfs
->os_bavail
= obd_osfs
.os_bavail
;
1591 /* If we don't have as many objects free on the OST as inodes
1592 * on the MDS, we reduce the total number of inodes to
1593 * compensate, so that the "inodes in use" number is correct.
1595 if (obd_osfs
.os_ffree
< osfs
->os_ffree
) {
1596 osfs
->os_files
= (osfs
->os_files
- osfs
->os_ffree
) +
1598 osfs
->os_ffree
= obd_osfs
.os_ffree
;
1603 int ll_statfs(struct dentry
*de
, struct kstatfs
*sfs
)
1605 struct super_block
*sb
= de
->d_sb
;
1606 struct obd_statfs osfs
;
1609 CDEBUG(D_VFSTRACE
, "VFS Op: at "LPU64
" jiffies\n", get_jiffies_64());
1610 ll_stats_ops_tally(ll_s2sbi(sb
), LPROC_LL_STAFS
, 1);
1612 /* Some amount of caching on the client is allowed */
1613 rc
= ll_statfs_internal(sb
, &osfs
,
1614 cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS
),
1619 statfs_unpack(sfs
, &osfs
);
1621 /* We need to downshift for all 32-bit kernels, because we can't
1622 * tell if the kernel is being called via sys_statfs64() or not.
1623 * Stop before overflowing f_bsize - in which case it is better
1624 * to just risk EOVERFLOW if caller is using old sys_statfs(). */
1625 if (sizeof(long) < 8) {
1626 while (osfs
.os_blocks
> ~0UL && sfs
->f_bsize
< 0x40000000) {
1629 osfs
.os_blocks
>>= 1;
1630 osfs
.os_bfree
>>= 1;
1631 osfs
.os_bavail
>>= 1;
1635 sfs
->f_blocks
= osfs
.os_blocks
;
1636 sfs
->f_bfree
= osfs
.os_bfree
;
1637 sfs
->f_bavail
= osfs
.os_bavail
;
1638 sfs
->f_fsid
= ll_s2sbi(sb
)->ll_fsid
;
1642 void ll_inode_size_lock(struct inode
*inode
)
1644 struct ll_inode_info
*lli
;
1646 LASSERT(!S_ISDIR(inode
->i_mode
));
1648 lli
= ll_i2info(inode
);
1649 mutex_lock(&lli
->lli_size_mutex
);
1652 void ll_inode_size_unlock(struct inode
*inode
)
1654 struct ll_inode_info
*lli
;
1656 lli
= ll_i2info(inode
);
1657 mutex_unlock(&lli
->lli_size_mutex
);
1660 void ll_update_inode(struct inode
*inode
, struct lustre_md
*md
)
1662 struct ll_inode_info
*lli
= ll_i2info(inode
);
1663 struct mdt_body
*body
= md
->body
;
1664 struct lov_stripe_md
*lsm
= md
->lsm
;
1665 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
1667 LASSERT ((lsm
!= NULL
) == ((body
->valid
& OBD_MD_FLEASIZE
) != 0));
1669 if (!lli
->lli_has_smd
&&
1670 !(sbi
->ll_flags
& LL_SBI_LAYOUT_LOCK
))
1671 cl_file_inode_init(inode
, md
);
1673 lli
->lli_maxbytes
= lsm
->lsm_maxbytes
;
1674 if (lli
->lli_maxbytes
> MAX_LFS_FILESIZE
)
1675 lli
->lli_maxbytes
= MAX_LFS_FILESIZE
;
1678 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
) {
1679 if (body
->valid
& OBD_MD_FLRMTPERM
)
1680 ll_update_remote_perm(inode
, md
->remote_perm
);
1682 #ifdef CONFIG_FS_POSIX_ACL
1683 else if (body
->valid
& OBD_MD_FLACL
) {
1684 spin_lock(&lli
->lli_lock
);
1685 if (lli
->lli_posix_acl
)
1686 posix_acl_release(lli
->lli_posix_acl
);
1687 lli
->lli_posix_acl
= md
->posix_acl
;
1688 spin_unlock(&lli
->lli_lock
);
1691 inode
->i_ino
= cl_fid_build_ino(&body
->fid1
,
1692 sbi
->ll_flags
& LL_SBI_32BIT_API
);
1693 inode
->i_generation
= cl_fid_build_gen(&body
->fid1
);
1695 if (body
->valid
& OBD_MD_FLATIME
) {
1696 if (body
->atime
> LTIME_S(inode
->i_atime
))
1697 LTIME_S(inode
->i_atime
) = body
->atime
;
1698 lli
->lli_lvb
.lvb_atime
= body
->atime
;
1700 if (body
->valid
& OBD_MD_FLMTIME
) {
1701 if (body
->mtime
> LTIME_S(inode
->i_mtime
)) {
1702 CDEBUG(D_INODE
, "setting ino %lu mtime from %lu "
1703 "to "LPU64
"\n", inode
->i_ino
,
1704 LTIME_S(inode
->i_mtime
), body
->mtime
);
1705 LTIME_S(inode
->i_mtime
) = body
->mtime
;
1707 lli
->lli_lvb
.lvb_mtime
= body
->mtime
;
1709 if (body
->valid
& OBD_MD_FLCTIME
) {
1710 if (body
->ctime
> LTIME_S(inode
->i_ctime
))
1711 LTIME_S(inode
->i_ctime
) = body
->ctime
;
1712 lli
->lli_lvb
.lvb_ctime
= body
->ctime
;
1714 if (body
->valid
& OBD_MD_FLMODE
)
1715 inode
->i_mode
= (inode
->i_mode
& S_IFMT
)|(body
->mode
& ~S_IFMT
);
1716 if (body
->valid
& OBD_MD_FLTYPE
)
1717 inode
->i_mode
= (inode
->i_mode
& ~S_IFMT
)|(body
->mode
& S_IFMT
);
1718 LASSERT(inode
->i_mode
!= 0);
1719 if (S_ISREG(inode
->i_mode
)) {
1720 inode
->i_blkbits
= min(PTLRPC_MAX_BRW_BITS
+ 1, LL_MAX_BLKSIZE_BITS
);
1722 inode
->i_blkbits
= inode
->i_sb
->s_blocksize_bits
;
1724 if (body
->valid
& OBD_MD_FLUID
)
1725 inode
->i_uid
= make_kuid(&init_user_ns
, body
->uid
);
1726 if (body
->valid
& OBD_MD_FLGID
)
1727 inode
->i_gid
= make_kgid(&init_user_ns
, body
->gid
);
1728 if (body
->valid
& OBD_MD_FLFLAGS
)
1729 inode
->i_flags
= ll_ext_to_inode_flags(body
->flags
);
1730 if (body
->valid
& OBD_MD_FLNLINK
)
1731 set_nlink(inode
, body
->nlink
);
1732 if (body
->valid
& OBD_MD_FLRDEV
)
1733 inode
->i_rdev
= old_decode_dev(body
->rdev
);
1735 if (body
->valid
& OBD_MD_FLID
) {
1736 /* FID shouldn't be changed! */
1737 if (fid_is_sane(&lli
->lli_fid
)) {
1738 LASSERTF(lu_fid_eq(&lli
->lli_fid
, &body
->fid1
),
1739 "Trying to change FID "DFID
1740 " to the "DFID
", inode %lu/%u(%p)\n",
1741 PFID(&lli
->lli_fid
), PFID(&body
->fid1
),
1742 inode
->i_ino
, inode
->i_generation
, inode
);
1744 lli
->lli_fid
= body
->fid1
;
1747 LASSERT(fid_seq(&lli
->lli_fid
) != 0);
1749 if (body
->valid
& OBD_MD_FLSIZE
) {
1750 if (exp_connect_som(ll_i2mdexp(inode
)) &&
1751 S_ISREG(inode
->i_mode
)) {
1752 struct lustre_handle lockh
;
1755 /* As it is possible a blocking ast has been processed
1756 * by this time, we need to check there is an UPDATE
1757 * lock on the client and set LLIF_MDS_SIZE_LOCK holding
1759 mode
= ll_take_md_lock(inode
, MDS_INODELOCK_UPDATE
,
1760 &lockh
, LDLM_FL_CBPENDING
,
1764 if (lli
->lli_flags
& (LLIF_DONE_WRITING
|
1765 LLIF_EPOCH_PENDING
|
1767 CERROR("ino %lu flags %u still has "
1768 "size authority! do not trust "
1769 "the size got from MDS\n",
1770 inode
->i_ino
, lli
->lli_flags
);
1772 /* Use old size assignment to avoid
1773 * deadlock bz14138 & bz14326 */
1774 i_size_write(inode
, body
->size
);
1775 spin_lock(&lli
->lli_lock
);
1776 lli
->lli_flags
|= LLIF_MDS_SIZE_LOCK
;
1777 spin_unlock(&lli
->lli_lock
);
1779 ldlm_lock_decref(&lockh
, mode
);
1782 /* Use old size assignment to avoid
1783 * deadlock bz14138 & bz14326 */
1784 i_size_write(inode
, body
->size
);
1786 CDEBUG(D_VFSTRACE
, "inode=%lu, updating i_size %llu\n",
1787 inode
->i_ino
, (unsigned long long)body
->size
);
1790 if (body
->valid
& OBD_MD_FLBLOCKS
)
1791 inode
->i_blocks
= body
->blocks
;
1794 if (body
->valid
& OBD_MD_FLMDSCAPA
) {
1795 LASSERT(md
->mds_capa
);
1796 ll_add_capa(inode
, md
->mds_capa
);
1798 if (body
->valid
& OBD_MD_FLOSSCAPA
) {
1799 LASSERT(md
->oss_capa
);
1800 ll_add_capa(inode
, md
->oss_capa
);
1803 if (body
->valid
& OBD_MD_TSTATE
) {
1804 if (body
->t_state
& MS_RESTORE
)
1805 lli
->lli_flags
|= LLIF_FILE_RESTORING
;
1809 void ll_read_inode2(struct inode
*inode
, void *opaque
)
1811 struct lustre_md
*md
= opaque
;
1812 struct ll_inode_info
*lli
= ll_i2info(inode
);
1814 CDEBUG(D_VFSTRACE
, "VFS Op:inode="DFID
"(%p)\n",
1815 PFID(&lli
->lli_fid
), inode
);
1817 LASSERT(!lli
->lli_has_smd
);
1819 /* Core attributes from the MDS first. This is a new inode, and
1820 * the VFS doesn't zero times in the core inode so we have to do
1821 * it ourselves. They will be overwritten by either MDS or OST
1822 * attributes - we just need to make sure they aren't newer. */
1823 LTIME_S(inode
->i_mtime
) = 0;
1824 LTIME_S(inode
->i_atime
) = 0;
1825 LTIME_S(inode
->i_ctime
) = 0;
1827 ll_update_inode(inode
, md
);
1829 /* OIDEBUG(inode); */
1831 /* initializing backing dev info. */
1832 inode
->i_mapping
->backing_dev_info
= &s2lsi(inode
->i_sb
)->lsi_bdi
;
1835 if (S_ISREG(inode
->i_mode
)) {
1836 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
1837 inode
->i_op
= &ll_file_inode_operations
;
1838 inode
->i_fop
= sbi
->ll_fop
;
1839 inode
->i_mapping
->a_ops
= (struct address_space_operations
*)&ll_aops
;
1840 } else if (S_ISDIR(inode
->i_mode
)) {
1841 inode
->i_op
= &ll_dir_inode_operations
;
1842 inode
->i_fop
= &ll_dir_operations
;
1843 } else if (S_ISLNK(inode
->i_mode
)) {
1844 inode
->i_op
= &ll_fast_symlink_inode_operations
;
1846 inode
->i_op
= &ll_special_inode_operations
;
1848 init_special_inode(inode
, inode
->i_mode
,
1853 void ll_delete_inode(struct inode
*inode
)
1855 struct cl_inode_info
*lli
= cl_i2info(inode
);
1857 if (S_ISREG(inode
->i_mode
) && lli
->lli_clob
!= NULL
)
1858 /* discard all dirty pages before truncating them, required by
1859 * osc_extent implementation at LU-1030. */
1860 cl_sync_file_range(inode
, 0, OBD_OBJECT_EOF
,
1861 CL_FSYNC_DISCARD
, 1);
1863 truncate_inode_pages_final(&inode
->i_data
);
1865 /* Workaround for LU-118 */
1866 if (inode
->i_data
.nrpages
) {
1867 TREE_READ_LOCK_IRQ(&inode
->i_data
);
1868 TREE_READ_UNLOCK_IRQ(&inode
->i_data
);
1869 LASSERTF(inode
->i_data
.nrpages
== 0,
1870 "inode=%lu/%u(%p) nrpages=%lu, see "
1871 "http://jira.whamcloud.com/browse/LU-118\n",
1872 inode
->i_ino
, inode
->i_generation
, inode
,
1873 inode
->i_data
.nrpages
);
1875 /* Workaround end */
1877 ll_clear_inode(inode
);
1881 int ll_iocontrol(struct inode
*inode
, struct file
*file
,
1882 unsigned int cmd
, unsigned long arg
)
1884 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
1885 struct ptlrpc_request
*req
= NULL
;
1889 case FSFILT_IOC_GETFLAGS
: {
1890 struct mdt_body
*body
;
1891 struct md_op_data
*op_data
;
1893 op_data
= ll_prep_md_op_data(NULL
, inode
, NULL
, NULL
,
1894 0, 0, LUSTRE_OPC_ANY
,
1896 if (IS_ERR(op_data
))
1897 return PTR_ERR(op_data
);
1899 op_data
->op_valid
= OBD_MD_FLFLAGS
;
1900 rc
= md_getattr(sbi
->ll_md_exp
, op_data
, &req
);
1901 ll_finish_md_op_data(op_data
);
1903 CERROR("failure %d inode %lu\n", rc
, inode
->i_ino
);
1907 body
= req_capsule_server_get(&req
->rq_pill
, &RMF_MDT_BODY
);
1909 flags
= body
->flags
;
1911 ptlrpc_req_finished(req
);
1913 return put_user(flags
, (int *)arg
);
1915 case FSFILT_IOC_SETFLAGS
: {
1916 struct lov_stripe_md
*lsm
;
1917 struct obd_info oinfo
= { { { 0 } } };
1918 struct md_op_data
*op_data
;
1920 if (get_user(flags
, (int *)arg
))
1923 op_data
= ll_prep_md_op_data(NULL
, inode
, NULL
, NULL
, 0, 0,
1924 LUSTRE_OPC_ANY
, NULL
);
1925 if (IS_ERR(op_data
))
1926 return PTR_ERR(op_data
);
1928 ((struct ll_iattr
*)&op_data
->op_attr
)->ia_attr_flags
= flags
;
1929 op_data
->op_attr
.ia_valid
|= ATTR_ATTR_FLAG
;
1930 rc
= md_setattr(sbi
->ll_md_exp
, op_data
,
1931 NULL
, 0, NULL
, 0, &req
, NULL
);
1932 ll_finish_md_op_data(op_data
);
1933 ptlrpc_req_finished(req
);
1937 inode
->i_flags
= ll_ext_to_inode_flags(flags
);
1939 lsm
= ccc_inode_lsm_get(inode
);
1940 if (!lsm_has_objects(lsm
)) {
1941 ccc_inode_lsm_put(inode
, lsm
);
1945 OBDO_ALLOC(oinfo
.oi_oa
);
1947 ccc_inode_lsm_put(inode
, lsm
);
1951 oinfo
.oi_oa
->o_oi
= lsm
->lsm_oi
;
1952 oinfo
.oi_oa
->o_flags
= flags
;
1953 oinfo
.oi_oa
->o_valid
= OBD_MD_FLID
| OBD_MD_FLFLAGS
|
1955 oinfo
.oi_capa
= ll_mdscapa_get(inode
);
1956 obdo_set_parent_fid(oinfo
.oi_oa
, &ll_i2info(inode
)->lli_fid
);
1957 rc
= obd_setattr_rqset(sbi
->ll_dt_exp
, &oinfo
, NULL
);
1958 capa_put(oinfo
.oi_capa
);
1959 OBDO_FREE(oinfo
.oi_oa
);
1960 ccc_inode_lsm_put(inode
, lsm
);
1962 if (rc
&& rc
!= -EPERM
&& rc
!= -EACCES
)
1963 CERROR("osc_setattr_async fails: rc = %d\n", rc
);
1974 int ll_flush_ctx(struct inode
*inode
)
1976 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
1978 CDEBUG(D_SEC
, "flush context for user %d\n",
1979 from_kuid(&init_user_ns
, current_uid()));
1981 obd_set_info_async(NULL
, sbi
->ll_md_exp
,
1982 sizeof(KEY_FLUSH_CTX
), KEY_FLUSH_CTX
,
1984 obd_set_info_async(NULL
, sbi
->ll_dt_exp
,
1985 sizeof(KEY_FLUSH_CTX
), KEY_FLUSH_CTX
,
1990 /* umount -f client means force down, don't save state */
1991 void ll_umount_begin(struct super_block
*sb
)
1993 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
1994 struct obd_device
*obd
;
1995 struct obd_ioctl_data
*ioc_data
;
1997 CDEBUG(D_VFSTRACE
, "VFS Op: superblock %p count %d active %d\n", sb
,
1998 sb
->s_count
, atomic_read(&sb
->s_active
));
2000 obd
= class_exp2obd(sbi
->ll_md_exp
);
2002 CERROR("Invalid MDC connection handle "LPX64
"\n",
2003 sbi
->ll_md_exp
->exp_handle
.h_cookie
);
2008 obd
= class_exp2obd(sbi
->ll_dt_exp
);
2010 CERROR("Invalid LOV connection handle "LPX64
"\n",
2011 sbi
->ll_dt_exp
->exp_handle
.h_cookie
);
2016 OBD_ALLOC_PTR(ioc_data
);
2018 obd_iocontrol(IOC_OSC_SET_ACTIVE
, sbi
->ll_md_exp
,
2019 sizeof(*ioc_data
), ioc_data
, NULL
);
2021 obd_iocontrol(IOC_OSC_SET_ACTIVE
, sbi
->ll_dt_exp
,
2022 sizeof(*ioc_data
), ioc_data
, NULL
);
2024 OBD_FREE_PTR(ioc_data
);
2027 /* Really, we'd like to wait until there are no requests outstanding,
2028 * and then continue. For now, we just invalidate the requests,
2029 * schedule() and sleep one second if needed, and hope.
2034 int ll_remount_fs(struct super_block
*sb
, int *flags
, char *data
)
2036 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
2037 char *profilenm
= get_profile_name(sb
);
2041 if ((*flags
& MS_RDONLY
) != (sb
->s_flags
& MS_RDONLY
)) {
2042 read_only
= *flags
& MS_RDONLY
;
2043 err
= obd_set_info_async(NULL
, sbi
->ll_md_exp
,
2044 sizeof(KEY_READ_ONLY
),
2045 KEY_READ_ONLY
, sizeof(read_only
),
2048 LCONSOLE_WARN("Failed to remount %s %s (%d)\n",
2049 profilenm
, read_only
?
2050 "read-only" : "read-write", err
);
2055 sb
->s_flags
|= MS_RDONLY
;
2057 sb
->s_flags
&= ~MS_RDONLY
;
2059 if (sbi
->ll_flags
& LL_SBI_VERBOSE
)
2060 LCONSOLE_WARN("Remounted %s %s\n", profilenm
,
2061 read_only
? "read-only" : "read-write");
2066 int ll_prep_inode(struct inode
**inode
, struct ptlrpc_request
*req
,
2067 struct super_block
*sb
, struct lookup_intent
*it
)
2069 struct ll_sb_info
*sbi
= NULL
;
2070 struct lustre_md md
;
2073 LASSERT(*inode
|| sb
);
2074 sbi
= sb
? ll_s2sbi(sb
) : ll_i2sbi(*inode
);
2075 rc
= md_get_lustre_md(sbi
->ll_md_exp
, req
, sbi
->ll_dt_exp
,
2076 sbi
->ll_md_exp
, &md
);
2081 ll_update_inode(*inode
, &md
);
2083 LASSERT(sb
!= NULL
);
2086 * At this point server returns to client's same fid as client
2087 * generated for creating. So using ->fid1 is okay here.
2089 LASSERT(fid_is_sane(&md
.body
->fid1
));
2091 *inode
= ll_iget(sb
, cl_fid_build_ino(&md
.body
->fid1
,
2092 sbi
->ll_flags
& LL_SBI_32BIT_API
),
2094 if (*inode
== NULL
|| IS_ERR(*inode
)) {
2095 #ifdef CONFIG_FS_POSIX_ACL
2097 posix_acl_release(md
.posix_acl
);
2098 md
.posix_acl
= NULL
;
2101 rc
= IS_ERR(*inode
) ? PTR_ERR(*inode
) : -ENOMEM
;
2103 CERROR("new_inode -fatal: rc %d\n", rc
);
2108 /* Handling piggyback layout lock.
2109 * Layout lock can be piggybacked by getattr and open request.
2110 * The lsm can be applied to inode only if it comes with a layout lock
2111 * otherwise correct layout may be overwritten, for example:
2112 * 1. proc1: mdt returns a lsm but not granting layout
2113 * 2. layout was changed by another client
2114 * 3. proc2: refresh layout and layout lock granted
2115 * 4. proc1: to apply a stale layout */
2116 if (it
!= NULL
&& it
->d
.lustre
.it_lock_mode
!= 0) {
2117 struct lustre_handle lockh
;
2118 struct ldlm_lock
*lock
;
2120 lockh
.cookie
= it
->d
.lustre
.it_lock_handle
;
2121 lock
= ldlm_handle2lock(&lockh
);
2122 LASSERT(lock
!= NULL
);
2123 if (ldlm_has_layout(lock
)) {
2124 struct cl_object_conf conf
;
2126 memset(&conf
, 0, sizeof(conf
));
2127 conf
.coc_opc
= OBJECT_CONF_SET
;
2128 conf
.coc_inode
= *inode
;
2129 conf
.coc_lock
= lock
;
2130 conf
.u
.coc_md
= &md
;
2131 (void)ll_layout_conf(*inode
, &conf
);
2133 LDLM_LOCK_PUT(lock
);
2138 obd_free_memmd(sbi
->ll_dt_exp
, &md
.lsm
);
2139 md_free_lustre_md(sbi
->ll_md_exp
, &md
);
2143 int ll_obd_statfs(struct inode
*inode
, void *arg
)
2145 struct ll_sb_info
*sbi
= NULL
;
2146 struct obd_export
*exp
;
2148 struct obd_ioctl_data
*data
= NULL
;
2153 if (!inode
|| !(sbi
= ll_i2sbi(inode
)))
2154 GOTO(out_statfs
, rc
= -EINVAL
);
2156 rc
= obd_ioctl_getdata(&buf
, &len
, arg
);
2158 GOTO(out_statfs
, rc
);
2161 if (!data
->ioc_inlbuf1
|| !data
->ioc_inlbuf2
||
2162 !data
->ioc_pbuf1
|| !data
->ioc_pbuf2
)
2163 GOTO(out_statfs
, rc
= -EINVAL
);
2165 if (data
->ioc_inllen1
!= sizeof(__u32
) ||
2166 data
->ioc_inllen2
!= sizeof(__u32
) ||
2167 data
->ioc_plen1
!= sizeof(struct obd_statfs
) ||
2168 data
->ioc_plen2
!= sizeof(struct obd_uuid
))
2169 GOTO(out_statfs
, rc
= -EINVAL
);
2171 memcpy(&type
, data
->ioc_inlbuf1
, sizeof(__u32
));
2172 if (type
& LL_STATFS_LMV
)
2173 exp
= sbi
->ll_md_exp
;
2174 else if (type
& LL_STATFS_LOV
)
2175 exp
= sbi
->ll_dt_exp
;
2177 GOTO(out_statfs
, rc
= -ENODEV
);
2179 flags
= (type
& LL_STATFS_NODELAY
) ? OBD_STATFS_NODELAY
: 0;
2180 rc
= obd_iocontrol(IOC_OBD_STATFS
, exp
, len
, buf
, &flags
);
2182 GOTO(out_statfs
, rc
);
2185 obd_ioctl_freedata(buf
, len
);
2189 int ll_process_config(struct lustre_cfg
*lcfg
)
2193 struct lprocfs_static_vars lvars
;
2197 lprocfs_llite_init_vars(&lvars
);
2199 /* The instance name contains the sb: lustre-client-aacfe000 */
2200 ptr
= strrchr(lustre_cfg_string(lcfg
, 0), '-');
2201 if (!ptr
|| !*(++ptr
))
2203 if (sscanf(ptr
, "%lx", &x
) != 1)
2206 /* This better be a real Lustre superblock! */
2207 LASSERT(s2lsi((struct super_block
*)sb
)->lsi_lmd
->lmd_magic
== LMD_MAGIC
);
2209 /* Note we have not called client_common_fill_super yet, so
2210 proc fns must be able to handle that! */
2211 rc
= class_process_proc_param(PARAM_LLITE
, lvars
.obd_vars
,
2218 /* this function prepares md_op_data hint for passing ot down to MD stack. */
2219 struct md_op_data
* ll_prep_md_op_data(struct md_op_data
*op_data
,
2220 struct inode
*i1
, struct inode
*i2
,
2221 const char *name
, int namelen
,
2222 int mode
, __u32 opc
, void *data
)
2224 LASSERT(i1
!= NULL
);
2226 if (namelen
> ll_i2sbi(i1
)->ll_namelen
)
2227 return ERR_PTR(-ENAMETOOLONG
);
2229 if (op_data
== NULL
)
2230 OBD_ALLOC_PTR(op_data
);
2232 if (op_data
== NULL
)
2233 return ERR_PTR(-ENOMEM
);
2235 ll_i2gids(op_data
->op_suppgids
, i1
, i2
);
2236 op_data
->op_fid1
= *ll_inode2fid(i1
);
2237 op_data
->op_capa1
= ll_mdscapa_get(i1
);
2240 op_data
->op_fid2
= *ll_inode2fid(i2
);
2241 op_data
->op_capa2
= ll_mdscapa_get(i2
);
2243 fid_zero(&op_data
->op_fid2
);
2244 op_data
->op_capa2
= NULL
;
2247 op_data
->op_name
= name
;
2248 op_data
->op_namelen
= namelen
;
2249 op_data
->op_mode
= mode
;
2250 op_data
->op_mod_time
= cfs_time_current_sec();
2251 op_data
->op_fsuid
= from_kuid(&init_user_ns
, current_fsuid());
2252 op_data
->op_fsgid
= from_kgid(&init_user_ns
, current_fsgid());
2253 op_data
->op_cap
= cfs_curproc_cap_pack();
2254 op_data
->op_bias
= 0;
2255 op_data
->op_cli_flags
= 0;
2256 if ((opc
== LUSTRE_OPC_CREATE
) && (name
!= NULL
) &&
2257 filename_is_volatile(name
, namelen
, NULL
))
2258 op_data
->op_bias
|= MDS_CREATE_VOLATILE
;
2259 op_data
->op_opc
= opc
;
2260 op_data
->op_mds
= 0;
2261 op_data
->op_data
= data
;
2263 /* If the file is being opened after mknod() (normally due to NFS)
2264 * try to use the default stripe data from parent directory for
2265 * allocating OST objects. Try to pass the parent FID to MDS. */
2266 if (opc
== LUSTRE_OPC_CREATE
&& i1
== i2
&& S_ISREG(i2
->i_mode
) &&
2267 !ll_i2info(i2
)->lli_has_smd
) {
2268 struct ll_inode_info
*lli
= ll_i2info(i2
);
2270 spin_lock(&lli
->lli_lock
);
2271 if (likely(!lli
->lli_has_smd
&& !fid_is_zero(&lli
->lli_pfid
)))
2272 op_data
->op_fid1
= lli
->lli_pfid
;
2273 spin_unlock(&lli
->lli_lock
);
2274 /** We ignore parent's capability temporary. */
2277 /* When called by ll_setattr_raw, file is i1. */
2278 if (LLIF_DATA_MODIFIED
& ll_i2info(i1
)->lli_flags
)
2279 op_data
->op_bias
|= MDS_DATA_MODIFIED
;
2284 void ll_finish_md_op_data(struct md_op_data
*op_data
)
2286 capa_put(op_data
->op_capa1
);
2287 capa_put(op_data
->op_capa2
);
2288 OBD_FREE_PTR(op_data
);
2291 int ll_show_options(struct seq_file
*seq
, struct dentry
*dentry
)
2293 struct ll_sb_info
*sbi
;
2295 LASSERT((seq
!= NULL
) && (dentry
!= NULL
));
2296 sbi
= ll_s2sbi(dentry
->d_sb
);
2298 if (sbi
->ll_flags
& LL_SBI_NOLCK
)
2299 seq_puts(seq
, ",nolock");
2301 if (sbi
->ll_flags
& LL_SBI_FLOCK
)
2302 seq_puts(seq
, ",flock");
2304 if (sbi
->ll_flags
& LL_SBI_LOCALFLOCK
)
2305 seq_puts(seq
, ",localflock");
2307 if (sbi
->ll_flags
& LL_SBI_USER_XATTR
)
2308 seq_puts(seq
, ",user_xattr");
2310 if (sbi
->ll_flags
& LL_SBI_LAZYSTATFS
)
2311 seq_puts(seq
, ",lazystatfs");
2313 if (sbi
->ll_flags
& LL_SBI_USER_FID2PATH
)
2314 seq_puts(seq
, ",user_fid2path");
2320 * Get obd name by cmd, and copy out to user space
2322 int ll_get_obd_name(struct inode
*inode
, unsigned int cmd
, unsigned long arg
)
2324 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
2325 struct obd_device
*obd
;
2327 if (cmd
== OBD_IOC_GETDTNAME
)
2328 obd
= class_exp2obd(sbi
->ll_dt_exp
);
2329 else if (cmd
== OBD_IOC_GETMDNAME
)
2330 obd
= class_exp2obd(sbi
->ll_md_exp
);
2337 if (copy_to_user((void *)arg
, obd
->obd_name
,
2338 strlen(obd
->obd_name
) + 1))
2345 * Get lustre file system name by \a sbi. If \a buf is provided(non-NULL), the
2346 * fsname will be returned in this buffer; otherwise, a static buffer will be
2347 * used to store the fsname and returned to caller.
2349 char *ll_get_fsname(struct super_block
*sb
, char *buf
, int buflen
)
2351 static char fsname_static
[MTI_NAME_MAXLEN
];
2352 struct lustre_sb_info
*lsi
= s2lsi(sb
);
2357 /* this means the caller wants to use static buffer
2358 * and it doesn't care about race. Usually this is
2359 * in error reporting path */
2360 buf
= fsname_static
;
2361 buflen
= sizeof(fsname_static
);
2364 len
= strlen(lsi
->lsi_lmd
->lmd_profile
);
2365 ptr
= strrchr(lsi
->lsi_lmd
->lmd_profile
, '-');
2366 if (ptr
&& (strcmp(ptr
, "-client") == 0))
2369 if (unlikely(len
>= buflen
))
2371 strncpy(buf
, lsi
->lsi_lmd
->lmd_profile
, len
);
2377 static char* ll_d_path(struct dentry
*dentry
, char *buf
, int bufsize
)
2384 p
.mnt
= current
->fs
->root
.mnt
;
2386 path
= d_path(&p
, buf
, bufsize
);
2392 void ll_dirty_page_discard_warn(struct page
*page
, int ioret
)
2394 char *buf
, *path
= NULL
;
2395 struct dentry
*dentry
= NULL
;
2396 struct ccc_object
*obj
= cl_inode2ccc(page
->mapping
->host
);
2398 /* this can be called inside spin lock so use GFP_ATOMIC. */
2399 buf
= (char *)__get_free_page(GFP_ATOMIC
);
2401 dentry
= d_find_alias(page
->mapping
->host
);
2403 path
= ll_d_path(dentry
, buf
, PAGE_SIZE
);
2407 "%s: dirty page discard: %s/fid: "DFID
"/%s may get corrupted "
2408 "(rc %d)\n", ll_get_fsname(page
->mapping
->host
->i_sb
, NULL
, 0),
2409 s2lsi(page
->mapping
->host
->i_sb
)->lsi_lmd
->lmd_dev
,
2410 PFID(&obj
->cob_header
.coh_lu
.loh_fid
),
2411 (path
&& !IS_ERR(path
)) ? path
: "", ioret
);
2417 free_page((unsigned long)buf
);