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/statfs.h>
45 #include <linux/types.h>
48 #include "../include/lustre_lite.h"
49 #include "../include/lustre_ha.h"
50 #include "../include/lustre_dlm.h"
51 #include "../include/lprocfs_status.h"
52 #include "../include/lustre_disk.h"
53 #include "../include/lustre_param.h"
54 #include "../include/lustre_log.h"
55 #include "../include/cl_object.h"
56 #include "../include/obd_cksum.h"
57 #include "llite_internal.h"
59 struct kmem_cache
*ll_file_data_slab
;
60 struct proc_dir_entry
*proc_lustre_fs_root
;
62 static LIST_HEAD(ll_super_blocks
);
63 static DEFINE_SPINLOCK(ll_sb_lock
);
66 #define log2(n) ffz(~(n))
69 static struct ll_sb_info
*ll_init_sbi(void)
71 struct ll_sb_info
*sbi
= NULL
;
73 unsigned long lru_page_max
;
78 sbi
= kzalloc(sizeof(*sbi
), GFP_NOFS
);
82 spin_lock_init(&sbi
->ll_lock
);
83 mutex_init(&sbi
->ll_lco
.lco_lock
);
84 spin_lock_init(&sbi
->ll_pp_extent_lock
);
85 spin_lock_init(&sbi
->ll_process_lock
);
86 sbi
->ll_rw_stats_on
= 0;
89 pages
= si
.totalram
- si
.totalhigh
;
90 if (pages
>> (20 - PAGE_CACHE_SHIFT
) < 512) {
91 lru_page_max
= pages
/ 2;
93 lru_page_max
= (pages
/ 4) * 3;
96 /* initialize lru data */
97 atomic_set(&sbi
->ll_cache
.ccc_users
, 0);
98 sbi
->ll_cache
.ccc_lru_max
= lru_page_max
;
99 atomic_set(&sbi
->ll_cache
.ccc_lru_left
, lru_page_max
);
100 spin_lock_init(&sbi
->ll_cache
.ccc_lru_lock
);
101 INIT_LIST_HEAD(&sbi
->ll_cache
.ccc_lru
);
103 sbi
->ll_ra_info
.ra_max_pages_per_file
= min(pages
/ 32,
104 SBI_DEFAULT_READAHEAD_MAX
);
105 sbi
->ll_ra_info
.ra_max_pages
= sbi
->ll_ra_info
.ra_max_pages_per_file
;
106 sbi
->ll_ra_info
.ra_max_read_ahead_whole_pages
=
107 SBI_DEFAULT_READAHEAD_WHOLE_MAX
;
108 INIT_LIST_HEAD(&sbi
->ll_conn_chain
);
109 INIT_LIST_HEAD(&sbi
->ll_orphan_dentry_list
);
111 ll_generate_random_uuid(uuid
);
112 class_uuid_unparse(uuid
, &sbi
->ll_sb_uuid
);
113 CDEBUG(D_CONFIG
, "generated uuid: %s\n", sbi
->ll_sb_uuid
.uuid
);
115 spin_lock(&ll_sb_lock
);
116 list_add_tail(&sbi
->ll_list
, &ll_super_blocks
);
117 spin_unlock(&ll_sb_lock
);
119 sbi
->ll_flags
|= LL_SBI_VERBOSE
;
120 sbi
->ll_flags
|= LL_SBI_CHECKSUM
;
122 sbi
->ll_flags
|= LL_SBI_LRU_RESIZE
;
124 for (i
= 0; i
<= LL_PROCESS_HIST_MAX
; i
++) {
125 spin_lock_init(&sbi
->ll_rw_extents_info
.pp_extents
[i
].
127 spin_lock_init(&sbi
->ll_rw_extents_info
.pp_extents
[i
].
131 /* metadata statahead is enabled by default */
132 sbi
->ll_sa_max
= LL_SA_RPC_DEF
;
133 atomic_set(&sbi
->ll_sa_total
, 0);
134 atomic_set(&sbi
->ll_sa_wrong
, 0);
135 atomic_set(&sbi
->ll_agl_total
, 0);
136 sbi
->ll_flags
|= LL_SBI_AGL_ENABLED
;
141 static void ll_free_sbi(struct super_block
*sb
)
143 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
146 spin_lock(&ll_sb_lock
);
147 list_del(&sbi
->ll_list
);
148 spin_unlock(&ll_sb_lock
);
149 OBD_FREE(sbi
, sizeof(*sbi
));
153 static int client_common_fill_super(struct super_block
*sb
, char *md
, char *dt
,
154 struct vfsmount
*mnt
)
156 struct inode
*root
= NULL
;
157 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
158 struct obd_device
*obd
;
159 struct obd_capa
*oc
= NULL
;
160 struct obd_statfs
*osfs
= NULL
;
161 struct ptlrpc_request
*request
= NULL
;
162 struct obd_connect_data
*data
= NULL
;
163 struct obd_uuid
*uuid
;
164 struct md_op_data
*op_data
;
165 struct lustre_md lmd
;
167 int size
, err
, checksum
;
169 obd
= class_name2obd(md
);
171 CERROR("MD %s: not setup or attached\n", md
);
175 data
= kzalloc(sizeof(*data
), GFP_NOFS
);
179 osfs
= kzalloc(sizeof(*osfs
), GFP_NOFS
);
185 if (proc_lustre_fs_root
) {
186 err
= lprocfs_register_mountpoint(proc_lustre_fs_root
, sb
,
189 CERROR("could not register mount in /proc/fs/lustre\n");
192 /* indicate the features supported by this client */
193 data
->ocd_connect_flags
= OBD_CONNECT_IBITS
| OBD_CONNECT_NODEVOH
|
194 OBD_CONNECT_ATTRFID
|
195 OBD_CONNECT_VERSION
| OBD_CONNECT_BRW_SIZE
|
196 OBD_CONNECT_MDS_CAPA
| OBD_CONNECT_OSS_CAPA
|
197 OBD_CONNECT_CANCELSET
| OBD_CONNECT_FID
|
198 OBD_CONNECT_AT
| OBD_CONNECT_LOV_V3
|
199 OBD_CONNECT_RMT_CLIENT
| OBD_CONNECT_VBR
|
200 OBD_CONNECT_FULL20
| OBD_CONNECT_64BITHASH
|
201 OBD_CONNECT_EINPROGRESS
|
202 OBD_CONNECT_JOBSTATS
| OBD_CONNECT_LVB_TYPE
|
203 OBD_CONNECT_LAYOUTLOCK
|
204 OBD_CONNECT_PINGLESS
|
205 OBD_CONNECT_MAX_EASIZE
|
206 OBD_CONNECT_FLOCK_DEAD
|
207 OBD_CONNECT_DISP_STRIPE
;
209 if (sbi
->ll_flags
& LL_SBI_SOM_PREVIEW
)
210 data
->ocd_connect_flags
|= OBD_CONNECT_SOM
;
212 if (sbi
->ll_flags
& LL_SBI_LRU_RESIZE
)
213 data
->ocd_connect_flags
|= OBD_CONNECT_LRU_RESIZE
;
214 #ifdef CONFIG_FS_POSIX_ACL
215 data
->ocd_connect_flags
|= OBD_CONNECT_ACL
| OBD_CONNECT_UMASK
;
218 if (OBD_FAIL_CHECK(OBD_FAIL_MDC_LIGHTWEIGHT
))
219 /* flag mdc connection as lightweight, only used for test
220 * purpose, use with care */
221 data
->ocd_connect_flags
|= OBD_CONNECT_LIGHTWEIGHT
;
223 data
->ocd_ibits_known
= MDS_INODELOCK_FULL
;
224 data
->ocd_version
= LUSTRE_VERSION_CODE
;
226 if (sb
->s_flags
& MS_RDONLY
)
227 data
->ocd_connect_flags
|= OBD_CONNECT_RDONLY
;
228 if (sbi
->ll_flags
& LL_SBI_USER_XATTR
)
229 data
->ocd_connect_flags
|= OBD_CONNECT_XATTR
;
231 #ifdef HAVE_MS_FLOCK_LOCK
232 /* force vfs to use lustre handler for flock() calls - bug 10743 */
233 sb
->s_flags
|= MS_FLOCK_LOCK
;
235 #ifdef MS_HAS_NEW_AOPS
236 sb
->s_flags
|= MS_HAS_NEW_AOPS
;
239 if (sbi
->ll_flags
& LL_SBI_FLOCK
)
240 sbi
->ll_fop
= &ll_file_operations_flock
;
241 else if (sbi
->ll_flags
& LL_SBI_LOCALFLOCK
)
242 sbi
->ll_fop
= &ll_file_operations
;
244 sbi
->ll_fop
= &ll_file_operations_noflock
;
247 data
->ocd_connect_flags
|= OBD_CONNECT_REAL
;
248 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
)
249 data
->ocd_connect_flags
|= OBD_CONNECT_RMT_CLIENT_FORCE
;
251 data
->ocd_brw_size
= MD_MAX_BRW_SIZE
;
253 err
= obd_connect(NULL
, &sbi
->ll_md_exp
, obd
, &sbi
->ll_sb_uuid
,
256 LCONSOLE_ERROR_MSG(0x14f, "An MDT (md %s) is performing recovery, of which this client is not a part. Please wait for recovery to complete, abort, or time out.\n",
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, rc = %d\n",
270 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
);
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 buf
= kzalloc(PAGE_CACHE_SIZE
, GFP_KERNEL
);
296 obd_connect_flags2str(buf
, PAGE_CACHE_SIZE
,
297 valid
^ CLIENT_CONNECT_MDT_REQD
, ",");
298 LCONSOLE_ERROR_MSG(0x170, "Server %s does not support feature(s) needed for correct operation of this client (%s). Please upgrade server or downgrade client.\n",
299 sbi
->ll_md_exp
->exp_obd
->obd_name
, buf
);
300 OBD_FREE(buf
, PAGE_CACHE_SIZE
);
305 size
= sizeof(*data
);
306 err
= obd_get_info(NULL
, sbi
->ll_md_exp
, sizeof(KEY_CONN_DATA
),
307 KEY_CONN_DATA
, &size
, data
, NULL
);
309 CERROR("%s: Get connect data failed: rc = %d\n",
310 sbi
->ll_md_exp
->exp_obd
->obd_name
, err
);
314 LASSERT(osfs
->os_bsize
);
315 sb
->s_blocksize
= osfs
->os_bsize
;
316 sb
->s_blocksize_bits
= log2(osfs
->os_bsize
);
317 sb
->s_magic
= LL_SUPER_MAGIC
;
318 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
319 sbi
->ll_namelen
= osfs
->os_namelen
;
320 sbi
->ll_max_rw_chunk
= LL_DEFAULT_MAX_RW_CHUNK
;
322 if ((sbi
->ll_flags
& LL_SBI_USER_XATTR
) &&
323 !(data
->ocd_connect_flags
& OBD_CONNECT_XATTR
)) {
324 LCONSOLE_INFO("Disabling user_xattr feature because it is not supported on the server\n");
325 sbi
->ll_flags
&= ~LL_SBI_USER_XATTR
;
328 if (data
->ocd_connect_flags
& OBD_CONNECT_ACL
) {
330 sb
->s_flags
|= MS_POSIXACL
;
332 sbi
->ll_flags
|= LL_SBI_ACL
;
334 LCONSOLE_INFO("client wants to enable acl, but mdt not!\n");
336 sb
->s_flags
&= ~MS_POSIXACL
;
338 sbi
->ll_flags
&= ~LL_SBI_ACL
;
341 if (data
->ocd_connect_flags
& OBD_CONNECT_RMT_CLIENT
) {
342 if (!(sbi
->ll_flags
& LL_SBI_RMT_CLIENT
)) {
343 sbi
->ll_flags
|= LL_SBI_RMT_CLIENT
;
344 LCONSOLE_INFO("client is set as remote by default.\n");
347 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
) {
348 sbi
->ll_flags
&= ~LL_SBI_RMT_CLIENT
;
349 LCONSOLE_INFO("client claims to be remote, but server rejected, forced to be local.\n");
353 if (data
->ocd_connect_flags
& OBD_CONNECT_MDS_CAPA
) {
354 LCONSOLE_INFO("client enabled MDS capability!\n");
355 sbi
->ll_flags
|= LL_SBI_MDS_CAPA
;
358 if (data
->ocd_connect_flags
& OBD_CONNECT_OSS_CAPA
) {
359 LCONSOLE_INFO("client enabled OSS capability!\n");
360 sbi
->ll_flags
|= LL_SBI_OSS_CAPA
;
363 if (data
->ocd_connect_flags
& OBD_CONNECT_64BITHASH
)
364 sbi
->ll_flags
|= LL_SBI_64BIT_HASH
;
366 if (data
->ocd_connect_flags
& OBD_CONNECT_BRW_SIZE
)
367 sbi
->ll_md_brw_size
= data
->ocd_brw_size
;
369 sbi
->ll_md_brw_size
= PAGE_CACHE_SIZE
;
371 if (data
->ocd_connect_flags
& OBD_CONNECT_LAYOUTLOCK
) {
372 LCONSOLE_INFO("Layout lock feature supported.\n");
373 sbi
->ll_flags
|= LL_SBI_LAYOUT_LOCK
;
376 if (data
->ocd_ibits_known
& MDS_INODELOCK_XATTR
) {
377 if (!(data
->ocd_connect_flags
& OBD_CONNECT_MAX_EASIZE
)) {
379 "%s: disabling xattr cache due to unknown maximum xattr size.\n",
382 sbi
->ll_flags
|= LL_SBI_XATTR_CACHE
;
383 sbi
->ll_xattr_cache_enabled
= 1;
387 obd
= class_name2obd(dt
);
389 CERROR("DT %s: not setup or attached\n", dt
);
394 data
->ocd_connect_flags
= OBD_CONNECT_GRANT
| OBD_CONNECT_VERSION
|
395 OBD_CONNECT_REQPORTAL
| OBD_CONNECT_BRW_SIZE
|
396 OBD_CONNECT_CANCELSET
| OBD_CONNECT_FID
|
397 OBD_CONNECT_SRVLOCK
| OBD_CONNECT_TRUNCLOCK
|
398 OBD_CONNECT_AT
| OBD_CONNECT_RMT_CLIENT
|
399 OBD_CONNECT_OSS_CAPA
| OBD_CONNECT_VBR
|
400 OBD_CONNECT_FULL20
| OBD_CONNECT_64BITHASH
|
401 OBD_CONNECT_MAXBYTES
|
402 OBD_CONNECT_EINPROGRESS
|
403 OBD_CONNECT_JOBSTATS
| OBD_CONNECT_LVB_TYPE
|
404 OBD_CONNECT_LAYOUTLOCK
| OBD_CONNECT_PINGLESS
;
406 if (sbi
->ll_flags
& LL_SBI_SOM_PREVIEW
)
407 data
->ocd_connect_flags
|= OBD_CONNECT_SOM
;
409 if (!OBD_FAIL_CHECK(OBD_FAIL_OSC_CONNECT_CKSUM
)) {
410 /* OBD_CONNECT_CKSUM should always be set, even if checksums are
411 * disabled by default, because it can still be enabled on the
412 * fly via /proc. As a consequence, we still need to come to an
413 * agreement on the supported algorithms at connect time */
414 data
->ocd_connect_flags
|= OBD_CONNECT_CKSUM
;
416 if (OBD_FAIL_CHECK(OBD_FAIL_OSC_CKSUM_ADLER_ONLY
))
417 data
->ocd_cksum_types
= OBD_CKSUM_ADLER
;
419 data
->ocd_cksum_types
= cksum_types_supported_client();
422 data
->ocd_connect_flags
|= OBD_CONNECT_LRU_RESIZE
;
423 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
)
424 data
->ocd_connect_flags
|= OBD_CONNECT_RMT_CLIENT_FORCE
;
426 CDEBUG(D_RPCTRACE
, "ocd_connect_flags: %#llx ocd_version: %d ocd_grant: %d\n",
427 data
->ocd_connect_flags
,
428 data
->ocd_version
, data
->ocd_grant
);
430 obd
->obd_upcall
.onu_owner
= &sbi
->ll_lco
;
431 obd
->obd_upcall
.onu_upcall
= cl_ocd_update
;
433 data
->ocd_brw_size
= DT_MAX_BRW_SIZE
;
435 err
= obd_connect(NULL
, &sbi
->ll_dt_exp
, obd
, &sbi
->ll_sb_uuid
, data
,
438 LCONSOLE_ERROR_MSG(0x150, "An OST (dt %s) is performing recovery, of which this client is not a part. Please wait for recovery to complete, abort, or time out.\n",
442 CERROR("%s: Cannot connect to %s: rc = %d\n",
443 sbi
->ll_dt_exp
->exp_obd
->obd_name
, dt
, err
);
447 sbi
->ll_dt_exp
->exp_connect_data
= *data
;
449 err
= obd_fid_init(sbi
->ll_dt_exp
->exp_obd
, sbi
->ll_dt_exp
,
450 LUSTRE_SEQ_METADATA
);
452 CERROR("%s: Can't init data layer FID infrastructure, rc = %d\n",
453 sbi
->ll_dt_exp
->exp_obd
->obd_name
, err
);
457 mutex_lock(&sbi
->ll_lco
.lco_lock
);
458 sbi
->ll_lco
.lco_flags
= data
->ocd_connect_flags
;
459 sbi
->ll_lco
.lco_md_exp
= sbi
->ll_md_exp
;
460 sbi
->ll_lco
.lco_dt_exp
= sbi
->ll_dt_exp
;
461 mutex_unlock(&sbi
->ll_lco
.lco_lock
);
463 fid_zero(&sbi
->ll_root_fid
);
464 err
= md_getstatus(sbi
->ll_md_exp
, &sbi
->ll_root_fid
, &oc
);
466 CERROR("cannot mds_connect: rc = %d\n", err
);
469 if (!fid_is_sane(&sbi
->ll_root_fid
)) {
470 CERROR("%s: Invalid root fid "DFID
" during mount\n",
471 sbi
->ll_md_exp
->exp_obd
->obd_name
,
472 PFID(&sbi
->ll_root_fid
));
476 CDEBUG(D_SUPER
, "rootfid "DFID
"\n", PFID(&sbi
->ll_root_fid
));
478 sb
->s_op
= &lustre_super_operations
;
479 #if THREAD_SIZE >= 8192 /*b=17630*/
480 sb
->s_export_op
= &lustre_export_operations
;
484 * XXX: move this to after cbd setup? */
485 valid
= OBD_MD_FLGETATTR
| OBD_MD_FLBLOCKS
| OBD_MD_FLMDSCAPA
;
486 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
)
487 valid
|= OBD_MD_FLRMTPERM
;
488 else if (sbi
->ll_flags
& LL_SBI_ACL
)
489 valid
|= OBD_MD_FLACL
;
491 op_data
= kzalloc(sizeof(*op_data
), GFP_NOFS
);
497 op_data
->op_fid1
= sbi
->ll_root_fid
;
498 op_data
->op_mode
= 0;
499 op_data
->op_capa1
= oc
;
500 op_data
->op_valid
= valid
;
502 err
= md_getattr(sbi
->ll_md_exp
, op_data
, &request
);
505 OBD_FREE_PTR(op_data
);
507 CERROR("%s: md_getattr failed for root: rc = %d\n",
508 sbi
->ll_md_exp
->exp_obd
->obd_name
, err
);
512 err
= md_get_lustre_md(sbi
->ll_md_exp
, request
, sbi
->ll_dt_exp
,
513 sbi
->ll_md_exp
, &lmd
);
515 CERROR("failed to understand root inode md: rc = %d\n", err
);
516 ptlrpc_req_finished(request
);
520 LASSERT(fid_is_sane(&sbi
->ll_root_fid
));
521 root
= ll_iget(sb
, cl_fid_build_ino(&sbi
->ll_root_fid
,
522 sbi
->ll_flags
& LL_SBI_32BIT_API
),
524 md_free_lustre_md(sbi
->ll_md_exp
, &lmd
);
525 ptlrpc_req_finished(request
);
527 if (root
== NULL
|| IS_ERR(root
)) {
529 obd_free_memmd(sbi
->ll_dt_exp
, &lmd
.lsm
);
530 #ifdef CONFIG_FS_POSIX_ACL
532 posix_acl_release(lmd
.posix_acl
);
533 lmd
.posix_acl
= NULL
;
536 err
= IS_ERR(root
) ? PTR_ERR(root
) : -EBADF
;
538 CERROR("lustre_lite: bad iget4 for root\n");
542 err
= ll_close_thread_start(&sbi
->ll_lcq
);
544 CERROR("cannot start close thread: rc %d\n", err
);
548 #ifdef CONFIG_FS_POSIX_ACL
549 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
) {
550 rct_init(&sbi
->ll_rct
);
551 et_init(&sbi
->ll_et
);
555 checksum
= sbi
->ll_flags
& LL_SBI_CHECKSUM
;
556 err
= obd_set_info_async(NULL
, sbi
->ll_dt_exp
, sizeof(KEY_CHECKSUM
),
557 KEY_CHECKSUM
, sizeof(checksum
), &checksum
,
561 err
= obd_set_info_async(NULL
, sbi
->ll_dt_exp
, sizeof(KEY_CACHE_SET
),
562 KEY_CACHE_SET
, sizeof(sbi
->ll_cache
),
563 &sbi
->ll_cache
, NULL
);
565 sb
->s_root
= d_make_root(root
);
566 if (sb
->s_root
== NULL
) {
567 CERROR("%s: can't make root dentry\n",
568 ll_get_fsname(sb
, NULL
, 0));
573 sbi
->ll_sdev_orig
= sb
->s_dev
;
575 /* We set sb->s_dev equal on all lustre clients in order to support
576 * NFS export clustering. NFSD requires that the FSID be the same
578 /* s_dev is also used in lt_compare() to compare two fs, but that is
579 * only a node-local comparison. */
580 uuid
= obd_get_uuid(sbi
->ll_md_exp
);
582 sb
->s_dev
= get_uuid2int(uuid
->uuid
, strlen(uuid
->uuid
));
583 get_uuid2fsid(uuid
->uuid
, strlen(uuid
->uuid
), &sbi
->ll_fsid
);
595 obd_fid_fini(sbi
->ll_dt_exp
->exp_obd
);
597 obd_disconnect(sbi
->ll_dt_exp
);
598 sbi
->ll_dt_exp
= NULL
;
599 /* Make sure all OScs are gone, since cl_cache is accessing sbi. */
600 obd_zombie_barrier();
602 obd_fid_fini(sbi
->ll_md_exp
->exp_obd
);
604 obd_disconnect(sbi
->ll_md_exp
);
605 sbi
->ll_md_exp
= NULL
;
611 lprocfs_unregister_mountpoint(sbi
);
615 int ll_get_max_mdsize(struct ll_sb_info
*sbi
, int *lmmsize
)
619 *lmmsize
= obd_size_diskmd(sbi
->ll_dt_exp
, NULL
);
621 rc
= obd_get_info(NULL
, sbi
->ll_md_exp
, sizeof(KEY_MAX_EASIZE
),
622 KEY_MAX_EASIZE
, &size
, lmmsize
, NULL
);
624 CERROR("Get max mdsize error rc %d \n", rc
);
629 int ll_get_default_mdsize(struct ll_sb_info
*sbi
, int *lmmsize
)
634 rc
= obd_get_info(NULL
, sbi
->ll_md_exp
, sizeof(KEY_DEFAULT_EASIZE
),
635 KEY_DEFAULT_EASIZE
, &size
, lmmsize
, NULL
);
637 CERROR("Get default mdsize error rc %d\n", rc
);
642 int ll_get_max_cookiesize(struct ll_sb_info
*sbi
, int *lmmsize
)
647 rc
= obd_get_info(NULL
, sbi
->ll_md_exp
, sizeof(KEY_MAX_COOKIESIZE
),
648 KEY_MAX_COOKIESIZE
, &size
, lmmsize
, NULL
);
650 CERROR("Get max cookiesize error rc %d\n", rc
);
655 int ll_get_default_cookiesize(struct ll_sb_info
*sbi
, int *lmmsize
)
660 rc
= obd_get_info(NULL
, sbi
->ll_md_exp
, sizeof(KEY_DEFAULT_COOKIESIZE
),
661 KEY_DEFAULT_COOKIESIZE
, &size
, lmmsize
, NULL
);
663 CERROR("Get default cookiesize error rc %d\n", rc
);
668 static void client_common_put_super(struct super_block
*sb
)
670 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
672 #ifdef CONFIG_FS_POSIX_ACL
673 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
) {
674 et_fini(&sbi
->ll_et
);
675 rct_fini(&sbi
->ll_rct
);
679 ll_close_thread_shutdown(sbi
->ll_lcq
);
683 list_del(&sbi
->ll_conn_chain
);
685 obd_fid_fini(sbi
->ll_dt_exp
->exp_obd
);
686 obd_disconnect(sbi
->ll_dt_exp
);
687 sbi
->ll_dt_exp
= NULL
;
688 /* wait till all OSCs are gone, since cl_cache is accessing sbi.
690 obd_zombie_barrier();
692 lprocfs_unregister_mountpoint(sbi
);
694 obd_fid_fini(sbi
->ll_md_exp
->exp_obd
);
695 obd_disconnect(sbi
->ll_md_exp
);
696 sbi
->ll_md_exp
= NULL
;
699 void ll_kill_super(struct super_block
*sb
)
701 struct ll_sb_info
*sbi
;
704 if (!(sb
->s_flags
& MS_ACTIVE
))
708 /* we need to restore s_dev from changed for clustered NFS before
709 * put_super because new kernels have cached s_dev and change sb->s_dev
710 * in put_super not affected real removing devices */
712 sb
->s_dev
= sbi
->ll_sdev_orig
;
713 sbi
->ll_umounting
= 1;
717 static inline int ll_set_opt(const char *opt
, char *data
, int fl
)
719 if (strncmp(opt
, data
, strlen(opt
)) != 0)
725 /* non-client-specific mount options are parsed in lmd_parse */
726 static int ll_options(char *options
, int *flags
)
729 char *s1
= options
, *s2
;
734 CDEBUG(D_CONFIG
, "Parsing opts %s\n", options
);
737 CDEBUG(D_SUPER
, "next opt=%s\n", s1
);
738 tmp
= ll_set_opt("nolock", s1
, LL_SBI_NOLCK
);
743 tmp
= ll_set_opt("flock", s1
, LL_SBI_FLOCK
);
748 tmp
= ll_set_opt("localflock", s1
, LL_SBI_LOCALFLOCK
);
753 tmp
= ll_set_opt("noflock", s1
, LL_SBI_FLOCK
|LL_SBI_LOCALFLOCK
);
758 tmp
= ll_set_opt("user_xattr", s1
, LL_SBI_USER_XATTR
);
763 tmp
= ll_set_opt("nouser_xattr", s1
, LL_SBI_USER_XATTR
);
768 tmp
= ll_set_opt("remote_client", s1
, LL_SBI_RMT_CLIENT
);
773 tmp
= ll_set_opt("user_fid2path", s1
, LL_SBI_USER_FID2PATH
);
778 tmp
= ll_set_opt("nouser_fid2path", s1
, LL_SBI_USER_FID2PATH
);
784 tmp
= ll_set_opt("checksum", s1
, LL_SBI_CHECKSUM
);
789 tmp
= ll_set_opt("nochecksum", s1
, LL_SBI_CHECKSUM
);
794 tmp
= ll_set_opt("lruresize", s1
, LL_SBI_LRU_RESIZE
);
799 tmp
= ll_set_opt("nolruresize", s1
, LL_SBI_LRU_RESIZE
);
804 tmp
= ll_set_opt("lazystatfs", s1
, LL_SBI_LAZYSTATFS
);
809 tmp
= ll_set_opt("nolazystatfs", s1
, LL_SBI_LAZYSTATFS
);
814 tmp
= ll_set_opt("som_preview", s1
, LL_SBI_SOM_PREVIEW
);
819 tmp
= ll_set_opt("32bitapi", s1
, LL_SBI_32BIT_API
);
824 tmp
= ll_set_opt("verbose", s1
, LL_SBI_VERBOSE
);
829 tmp
= ll_set_opt("noverbose", s1
, LL_SBI_VERBOSE
);
834 LCONSOLE_ERROR_MSG(0x152, "Unknown option '%s', won't mount.\n",
840 s2
= strchr(s1
, ',');
848 void ll_lli_init(struct ll_inode_info
*lli
)
850 lli
->lli_inode_magic
= LLI_INODE_MAGIC
;
852 lli
->lli_ioepoch
= 0;
853 lli
->lli_maxbytes
= MAX_LFS_FILESIZE
;
854 spin_lock_init(&lli
->lli_lock
);
855 lli
->lli_posix_acl
= NULL
;
856 lli
->lli_remote_perms
= NULL
;
857 mutex_init(&lli
->lli_rmtperm_mutex
);
858 /* Do not set lli_fid, it has been initialized already. */
859 fid_zero(&lli
->lli_pfid
);
860 INIT_LIST_HEAD(&lli
->lli_close_list
);
861 INIT_LIST_HEAD(&lli
->lli_oss_capas
);
862 atomic_set(&lli
->lli_open_count
, 0);
863 lli
->lli_mds_capa
= NULL
;
864 lli
->lli_rmtperm_time
= 0;
865 lli
->lli_pending_och
= NULL
;
866 lli
->lli_mds_read_och
= NULL
;
867 lli
->lli_mds_write_och
= NULL
;
868 lli
->lli_mds_exec_och
= NULL
;
869 lli
->lli_open_fd_read_count
= 0;
870 lli
->lli_open_fd_write_count
= 0;
871 lli
->lli_open_fd_exec_count
= 0;
872 mutex_init(&lli
->lli_och_mutex
);
873 spin_lock_init(&lli
->lli_agl_lock
);
874 lli
->lli_has_smd
= false;
875 spin_lock_init(&lli
->lli_layout_lock
);
876 ll_layout_version_set(lli
, LL_LAYOUT_GEN_NONE
);
877 lli
->lli_clob
= NULL
;
879 init_rwsem(&lli
->lli_xattrs_list_rwsem
);
880 mutex_init(&lli
->lli_xattrs_enq_lock
);
882 LASSERT(lli
->lli_vfs_inode
.i_mode
!= 0);
883 if (S_ISDIR(lli
->lli_vfs_inode
.i_mode
)) {
884 mutex_init(&lli
->lli_readdir_mutex
);
885 lli
->lli_opendir_key
= NULL
;
887 spin_lock_init(&lli
->lli_sa_lock
);
888 lli
->lli_opendir_pid
= 0;
890 mutex_init(&lli
->lli_size_mutex
);
891 lli
->lli_symlink_name
= NULL
;
892 init_rwsem(&lli
->lli_trunc_sem
);
893 mutex_init(&lli
->lli_write_mutex
);
894 init_rwsem(&lli
->lli_glimpse_sem
);
895 lli
->lli_glimpse_time
= 0;
896 INIT_LIST_HEAD(&lli
->lli_agl_list
);
897 lli
->lli_agl_index
= 0;
898 lli
->lli_async_rc
= 0;
900 mutex_init(&lli
->lli_layout_mutex
);
903 static inline int ll_bdi_register(struct backing_dev_info
*bdi
)
905 static atomic_t ll_bdi_num
= ATOMIC_INIT(0);
907 bdi
->name
= "lustre";
908 return bdi_register(bdi
, NULL
, "lustre-%d",
909 atomic_inc_return(&ll_bdi_num
));
912 int ll_fill_super(struct super_block
*sb
, struct vfsmount
*mnt
)
914 struct lustre_profile
*lprof
= NULL
;
915 struct lustre_sb_info
*lsi
= s2lsi(sb
);
916 struct ll_sb_info
*sbi
;
917 char *dt
= NULL
, *md
= NULL
;
918 char *profilenm
= get_profile_name(sb
);
919 struct config_llog_instance
*cfg
;
920 /* %p for void* in printf needs 16+2 characters: 0xffffffffffffffff */
921 const int instlen
= sizeof(cfg
->cfg_instance
) * 2 + 2;
924 CDEBUG(D_VFSTRACE
, "VFS Op: sb %p\n", sb
);
926 cfg
= kzalloc(sizeof(*cfg
), GFP_NOFS
);
930 try_module_get(THIS_MODULE
);
932 /* client additional sb info */
933 lsi
->lsi_llsbi
= sbi
= ll_init_sbi();
935 module_put(THIS_MODULE
);
940 err
= ll_options(lsi
->lsi_lmd
->lmd_opts
, &sbi
->ll_flags
);
944 err
= bdi_init(&lsi
->lsi_bdi
);
947 lsi
->lsi_flags
|= LSI_BDI_INITIALIZED
;
948 lsi
->lsi_bdi
.capabilities
= 0;
949 err
= ll_bdi_register(&lsi
->lsi_bdi
);
953 sb
->s_bdi
= &lsi
->lsi_bdi
;
954 /* kernel >= 2.6.38 store dentry operations in sb->s_d_op. */
955 sb
->s_d_op
= &ll_d_ops
;
957 /* Generate a string unique to this super, in case some joker tries
958 to mount the same fs at two mount points.
959 Use the address of the super itself.*/
960 cfg
->cfg_instance
= sb
;
961 cfg
->cfg_uuid
= lsi
->lsi_llsbi
->ll_sb_uuid
;
962 cfg
->cfg_callback
= class_config_llog_handler
;
963 /* set up client obds */
964 err
= lustre_process_log(sb
, profilenm
, cfg
);
966 CERROR("Unable to process log: %d\n", err
);
970 /* Profile set with LCFG_MOUNTOPT so we can find our mdc and osc obds */
971 lprof
= class_get_profile(profilenm
);
973 LCONSOLE_ERROR_MSG(0x156, "The client profile '%s' could not be read from the MGS. Does that filesystem exist?\n",
978 CDEBUG(D_CONFIG
, "Found profile %s: mdc=%s osc=%s\n", profilenm
,
979 lprof
->lp_md
, lprof
->lp_dt
);
981 dt
= kzalloc(strlen(lprof
->lp_dt
) + instlen
+ 2, GFP_NOFS
);
986 sprintf(dt
, "%s-%p", lprof
->lp_dt
, cfg
->cfg_instance
);
988 md
= kzalloc(strlen(lprof
->lp_md
) + instlen
+ 2, GFP_NOFS
);
993 sprintf(md
, "%s-%p", lprof
->lp_md
, cfg
->cfg_instance
);
995 /* connections, registrations, sb setup */
996 err
= client_common_fill_super(sb
, md
, dt
, mnt
);
1000 OBD_FREE(md
, strlen(lprof
->lp_md
) + instlen
+ 2);
1002 OBD_FREE(dt
, strlen(lprof
->lp_dt
) + instlen
+ 2);
1005 else if (sbi
->ll_flags
& LL_SBI_VERBOSE
)
1006 LCONSOLE_WARN("Mounted %s\n", profilenm
);
1010 } /* ll_fill_super */
1012 void ll_put_super(struct super_block
*sb
)
1014 struct config_llog_instance cfg
, params_cfg
;
1015 struct obd_device
*obd
;
1016 struct lustre_sb_info
*lsi
= s2lsi(sb
);
1017 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
1018 char *profilenm
= get_profile_name(sb
);
1019 int next
, force
= 1;
1021 CDEBUG(D_VFSTRACE
, "VFS Op: sb %p - %s\n", sb
, profilenm
);
1023 ll_print_capa_stat(sbi
);
1025 cfg
.cfg_instance
= sb
;
1026 lustre_end_log(sb
, profilenm
, &cfg
);
1028 params_cfg
.cfg_instance
= sb
;
1029 lustre_end_log(sb
, PARAMS_FILENAME
, ¶ms_cfg
);
1031 if (sbi
->ll_md_exp
) {
1032 obd
= class_exp2obd(sbi
->ll_md_exp
);
1034 force
= obd
->obd_force
;
1037 /* We need to set force before the lov_disconnect in
1038 lustre_common_put_super, since l_d cleans up osc's as well. */
1041 while ((obd
= class_devices_in_group(&sbi
->ll_sb_uuid
,
1043 obd
->obd_force
= force
;
1048 /* Only if client_common_fill_super succeeded */
1049 client_common_put_super(sb
);
1053 while ((obd
= class_devices_in_group(&sbi
->ll_sb_uuid
, &next
)))
1054 class_manual_cleanup(obd
);
1056 if (sbi
->ll_flags
& LL_SBI_VERBOSE
)
1057 LCONSOLE_WARN("Unmounted %s\n", profilenm
? profilenm
: "");
1060 class_del_profile(profilenm
);
1062 if (lsi
->lsi_flags
& LSI_BDI_INITIALIZED
) {
1063 bdi_destroy(&lsi
->lsi_bdi
);
1064 lsi
->lsi_flags
&= ~LSI_BDI_INITIALIZED
;
1068 lsi
->lsi_llsbi
= NULL
;
1070 lustre_common_put_super(sb
);
1072 module_put(THIS_MODULE
);
1073 } /* client_put_super */
1075 struct inode
*ll_inode_from_resource_lock(struct ldlm_lock
*lock
)
1077 struct inode
*inode
= NULL
;
1079 /* NOTE: we depend on atomic igrab() -bzzz */
1080 lock_res_and_lock(lock
);
1081 if (lock
->l_resource
->lr_lvb_inode
) {
1082 struct ll_inode_info
*lli
;
1084 lli
= ll_i2info(lock
->l_resource
->lr_lvb_inode
);
1085 if (lli
->lli_inode_magic
== LLI_INODE_MAGIC
) {
1086 inode
= igrab(lock
->l_resource
->lr_lvb_inode
);
1088 inode
= lock
->l_resource
->lr_lvb_inode
;
1089 LDLM_DEBUG_LIMIT(inode
->i_state
& I_FREEING
? D_INFO
:
1090 D_WARNING
, lock
, "lr_lvb_inode %p is bogus: magic %08x",
1091 lock
->l_resource
->lr_lvb_inode
,
1092 lli
->lli_inode_magic
);
1096 unlock_res_and_lock(lock
);
1100 void ll_clear_inode(struct inode
*inode
)
1102 struct ll_inode_info
*lli
= ll_i2info(inode
);
1103 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
1105 CDEBUG(D_VFSTRACE
, "VFS Op:inode=%lu/%u(%p)\n", inode
->i_ino
,
1106 inode
->i_generation
, inode
);
1108 if (S_ISDIR(inode
->i_mode
)) {
1109 /* these should have been cleared in ll_file_release */
1110 LASSERT(lli
->lli_opendir_key
== NULL
);
1111 LASSERT(lli
->lli_sai
== NULL
);
1112 LASSERT(lli
->lli_opendir_pid
== 0);
1115 spin_lock(&lli
->lli_lock
);
1116 ll_i2info(inode
)->lli_flags
&= ~LLIF_MDS_SIZE_LOCK
;
1117 spin_unlock(&lli
->lli_lock
);
1118 md_null_inode(sbi
->ll_md_exp
, ll_inode2fid(inode
));
1120 LASSERT(!lli
->lli_open_fd_write_count
);
1121 LASSERT(!lli
->lli_open_fd_read_count
);
1122 LASSERT(!lli
->lli_open_fd_exec_count
);
1124 if (lli
->lli_mds_write_och
)
1125 ll_md_real_close(inode
, FMODE_WRITE
);
1126 if (lli
->lli_mds_exec_och
)
1127 ll_md_real_close(inode
, FMODE_EXEC
);
1128 if (lli
->lli_mds_read_och
)
1129 ll_md_real_close(inode
, FMODE_READ
);
1131 if (S_ISLNK(inode
->i_mode
) && lli
->lli_symlink_name
) {
1132 OBD_FREE(lli
->lli_symlink_name
,
1133 strlen(lli
->lli_symlink_name
) + 1);
1134 lli
->lli_symlink_name
= NULL
;
1137 ll_xattr_cache_destroy(inode
);
1139 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
) {
1140 LASSERT(lli
->lli_posix_acl
== NULL
);
1141 if (lli
->lli_remote_perms
) {
1142 free_rmtperm_hash(lli
->lli_remote_perms
);
1143 lli
->lli_remote_perms
= NULL
;
1146 #ifdef CONFIG_FS_POSIX_ACL
1147 else if (lli
->lli_posix_acl
) {
1148 LASSERT(atomic_read(&lli
->lli_posix_acl
->a_refcount
) == 1);
1149 LASSERT(lli
->lli_remote_perms
== NULL
);
1150 posix_acl_release(lli
->lli_posix_acl
);
1151 lli
->lli_posix_acl
= NULL
;
1154 lli
->lli_inode_magic
= LLI_INODE_DEAD
;
1156 ll_clear_inode_capas(inode
);
1157 if (!S_ISDIR(inode
->i_mode
))
1158 LASSERT(list_empty(&lli
->lli_agl_list
));
1161 * XXX This has to be done before lsm is freed below, because
1162 * cl_object still uses inode lsm.
1164 cl_inode_fini(inode
);
1165 lli
->lli_has_smd
= false;
1168 static int ll_md_setattr(struct dentry
*dentry
, struct md_op_data
*op_data
,
1169 struct md_open_data
**mod
)
1171 struct lustre_md md
;
1172 struct inode
*inode
= d_inode(dentry
);
1173 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
1174 struct ptlrpc_request
*request
= NULL
;
1177 op_data
= ll_prep_md_op_data(op_data
, inode
, NULL
, NULL
, 0, 0,
1178 LUSTRE_OPC_ANY
, NULL
);
1179 if (IS_ERR(op_data
))
1180 return PTR_ERR(op_data
);
1182 rc
= md_setattr(sbi
->ll_md_exp
, op_data
, NULL
, 0, NULL
, 0,
1185 ptlrpc_req_finished(request
);
1186 if (rc
== -ENOENT
) {
1188 /* Unlinked special device node? Or just a race?
1189 * Pretend we done everything. */
1190 if (!S_ISREG(inode
->i_mode
) &&
1191 !S_ISDIR(inode
->i_mode
)) {
1192 ia_valid
= op_data
->op_attr
.ia_valid
;
1193 op_data
->op_attr
.ia_valid
&= ~TIMES_SET_FLAGS
;
1194 rc
= simple_setattr(dentry
, &op_data
->op_attr
);
1195 op_data
->op_attr
.ia_valid
= ia_valid
;
1197 } else if (rc
!= -EPERM
&& rc
!= -EACCES
&& rc
!= -ETXTBSY
) {
1198 CERROR("md_setattr fails: rc = %d\n", rc
);
1203 rc
= md_get_lustre_md(sbi
->ll_md_exp
, request
, sbi
->ll_dt_exp
,
1204 sbi
->ll_md_exp
, &md
);
1206 ptlrpc_req_finished(request
);
1210 ia_valid
= op_data
->op_attr
.ia_valid
;
1211 /* inode size will be in ll_setattr_ost, can't do it now since dirty
1212 * cache is not cleared yet. */
1213 op_data
->op_attr
.ia_valid
&= ~(TIMES_SET_FLAGS
| ATTR_SIZE
);
1214 rc
= simple_setattr(dentry
, &op_data
->op_attr
);
1215 op_data
->op_attr
.ia_valid
= ia_valid
;
1217 /* Extract epoch data if obtained. */
1218 op_data
->op_handle
= md
.body
->handle
;
1219 op_data
->op_ioepoch
= md
.body
->ioepoch
;
1221 ll_update_inode(inode
, &md
);
1222 ptlrpc_req_finished(request
);
1227 /* Close IO epoch and send Size-on-MDS attribute update. */
1228 static int ll_setattr_done_writing(struct inode
*inode
,
1229 struct md_op_data
*op_data
,
1230 struct md_open_data
*mod
)
1232 struct ll_inode_info
*lli
= ll_i2info(inode
);
1235 LASSERT(op_data
!= NULL
);
1236 if (!S_ISREG(inode
->i_mode
))
1239 CDEBUG(D_INODE
, "Epoch %llu closed on "DFID
" for truncate\n",
1240 op_data
->op_ioepoch
, PFID(&lli
->lli_fid
));
1242 op_data
->op_flags
= MF_EPOCH_CLOSE
;
1243 ll_done_writing_attr(inode
, op_data
);
1244 ll_pack_inode2opdata(inode
, op_data
, NULL
);
1246 rc
= md_done_writing(ll_i2sbi(inode
)->ll_md_exp
, op_data
, mod
);
1247 if (rc
== -EAGAIN
) {
1248 /* MDS has instructed us to obtain Size-on-MDS attribute
1249 * from OSTs and send setattr to back to MDS. */
1250 rc
= ll_som_update(inode
, op_data
);
1252 CERROR("inode %lu mdc truncate failed: rc = %d\n",
1258 static int ll_setattr_ost(struct inode
*inode
, struct iattr
*attr
)
1260 struct obd_capa
*capa
;
1263 if (attr
->ia_valid
& ATTR_SIZE
)
1264 capa
= ll_osscapa_get(inode
, CAPA_OPC_OSS_TRUNC
);
1266 capa
= ll_mdscapa_get(inode
);
1268 rc
= cl_setattr_ost(inode
, attr
, capa
);
1270 if (attr
->ia_valid
& ATTR_SIZE
)
1271 ll_truncate_free_capa(capa
);
1279 /* If this inode has objects allocated to it (lsm != NULL), then the OST
1280 * object(s) determine the file size and mtime. Otherwise, the MDS will
1281 * keep these values until such a time that objects are allocated for it.
1282 * We do the MDS operations first, as it is checking permissions for us.
1283 * We don't to the MDS RPC if there is nothing that we want to store there,
1284 * otherwise there is no harm in updating mtime/atime on the MDS if we are
1285 * going to do an RPC anyways.
1287 * If we are doing a truncate, we will send the mtime and ctime updates
1288 * to the OST with the punch RPC, otherwise we do an explicit setattr RPC.
1289 * I don't believe it is possible to get e.g. ATTR_MTIME_SET and ATTR_SIZE
1292 * In case of HSMimport, we only set attr on MDS.
1294 int ll_setattr_raw(struct dentry
*dentry
, struct iattr
*attr
, bool hsm_import
)
1296 struct inode
*inode
= d_inode(dentry
);
1297 struct ll_inode_info
*lli
= ll_i2info(inode
);
1298 struct md_op_data
*op_data
= NULL
;
1299 struct md_open_data
*mod
= NULL
;
1300 bool file_is_released
= false;
1301 int rc
= 0, rc1
= 0;
1304 "%s: setattr inode %p/fid:"DFID
1305 " from %llu to %llu, valid %x, hsm_import %d\n",
1306 ll_get_fsname(inode
->i_sb
, NULL
, 0), inode
,
1307 PFID(&lli
->lli_fid
), i_size_read(inode
), attr
->ia_size
,
1308 attr
->ia_valid
, hsm_import
);
1310 if (attr
->ia_valid
& ATTR_SIZE
) {
1311 /* Check new size against VFS/VM file size limit and rlimit */
1312 rc
= inode_newsize_ok(inode
, attr
->ia_size
);
1316 /* The maximum Lustre file size is variable, based on the
1317 * OST maximum object size and number of stripes. This
1318 * needs another check in addition to the VFS check above. */
1319 if (attr
->ia_size
> ll_file_maxbytes(inode
)) {
1320 CDEBUG(D_INODE
, "file "DFID
" too large %llu > %llu\n",
1321 PFID(&lli
->lli_fid
), attr
->ia_size
,
1322 ll_file_maxbytes(inode
));
1326 attr
->ia_valid
|= ATTR_MTIME
| ATTR_CTIME
;
1329 /* POSIX: check before ATTR_*TIME_SET set (from inode_change_ok) */
1330 if (attr
->ia_valid
& TIMES_SET_FLAGS
) {
1331 if ((!uid_eq(current_fsuid(), inode
->i_uid
)) &&
1332 !capable(CFS_CAP_FOWNER
))
1336 /* We mark all of the fields "set" so MDS/OST does not re-set them */
1337 if (attr
->ia_valid
& ATTR_CTIME
) {
1338 attr
->ia_ctime
= CURRENT_TIME
;
1339 attr
->ia_valid
|= ATTR_CTIME_SET
;
1341 if (!(attr
->ia_valid
& ATTR_ATIME_SET
) &&
1342 (attr
->ia_valid
& ATTR_ATIME
)) {
1343 attr
->ia_atime
= CURRENT_TIME
;
1344 attr
->ia_valid
|= ATTR_ATIME_SET
;
1346 if (!(attr
->ia_valid
& ATTR_MTIME_SET
) &&
1347 (attr
->ia_valid
& ATTR_MTIME
)) {
1348 attr
->ia_mtime
= CURRENT_TIME
;
1349 attr
->ia_valid
|= ATTR_MTIME_SET
;
1352 if (attr
->ia_valid
& (ATTR_MTIME
| ATTR_CTIME
))
1353 CDEBUG(D_INODE
, "setting mtime %lu, ctime %lu, now = %lu\n",
1354 LTIME_S(attr
->ia_mtime
), LTIME_S(attr
->ia_ctime
),
1357 /* If we are changing file size, file content is modified, flag it. */
1358 if (attr
->ia_valid
& ATTR_SIZE
) {
1359 attr
->ia_valid
|= MDS_OPEN_OWNEROVERRIDE
;
1360 spin_lock(&lli
->lli_lock
);
1361 lli
->lli_flags
|= LLIF_DATA_MODIFIED
;
1362 spin_unlock(&lli
->lli_lock
);
1365 /* We always do an MDS RPC, even if we're only changing the size;
1366 * only the MDS knows whether truncate() should fail with -ETXTBUSY */
1368 op_data
= kzalloc(sizeof(*op_data
), GFP_NOFS
);
1372 if (!S_ISDIR(inode
->i_mode
)) {
1373 if (attr
->ia_valid
& ATTR_SIZE
)
1374 inode_dio_write_done(inode
);
1375 mutex_unlock(&inode
->i_mutex
);
1378 memcpy(&op_data
->op_attr
, attr
, sizeof(*attr
));
1380 /* Open epoch for truncate. */
1381 if (exp_connect_som(ll_i2mdexp(inode
)) &&
1382 (attr
->ia_valid
& (ATTR_SIZE
| ATTR_MTIME
| ATTR_MTIME_SET
)))
1383 op_data
->op_flags
= MF_EPOCH_OPEN
;
1385 /* truncate on a released file must failed with -ENODATA,
1386 * so size must not be set on MDS for released file
1387 * but other attributes must be set
1389 if (S_ISREG(inode
->i_mode
)) {
1390 struct lov_stripe_md
*lsm
;
1393 ll_layout_refresh(inode
, &gen
);
1394 lsm
= ccc_inode_lsm_get(inode
);
1395 if (lsm
&& lsm
->lsm_pattern
& LOV_PATTERN_F_RELEASED
)
1396 file_is_released
= true;
1397 ccc_inode_lsm_put(inode
, lsm
);
1400 /* if not in HSM import mode, clear size attr for released file
1401 * we clear the attribute send to MDT in op_data, not the original
1402 * received from caller in attr which is used later to
1403 * decide return code */
1404 if (file_is_released
&& (attr
->ia_valid
& ATTR_SIZE
) && !hsm_import
)
1405 op_data
->op_attr
.ia_valid
&= ~ATTR_SIZE
;
1407 rc
= ll_md_setattr(dentry
, op_data
, &mod
);
1411 /* truncate failed (only when non HSM import), others succeed */
1412 if (file_is_released
) {
1413 if ((attr
->ia_valid
& ATTR_SIZE
) && !hsm_import
)
1420 /* RPC to MDT is sent, cancel data modification flag */
1421 if (rc
== 0 && (op_data
->op_bias
& MDS_DATA_MODIFIED
)) {
1422 spin_lock(&lli
->lli_lock
);
1423 lli
->lli_flags
&= ~LLIF_DATA_MODIFIED
;
1424 spin_unlock(&lli
->lli_lock
);
1427 ll_ioepoch_open(lli
, op_data
->op_ioepoch
);
1428 if (!S_ISREG(inode
->i_mode
)) {
1433 if (attr
->ia_valid
& (ATTR_SIZE
|
1434 ATTR_ATIME
| ATTR_ATIME_SET
|
1435 ATTR_MTIME
| ATTR_MTIME_SET
))
1436 /* For truncate and utimes sending attributes to OSTs, setting
1437 * mtime/atime to the past will be performed under PW [0:EOF]
1438 * extent lock (new_size:EOF for truncate). It may seem
1439 * excessive to send mtime/atime updates to OSTs when not
1440 * setting times to past, but it is necessary due to possible
1441 * time de-synchronization between MDT inode and OST objects */
1442 if (attr
->ia_valid
& ATTR_SIZE
)
1443 down_write(&lli
->lli_trunc_sem
);
1444 rc
= ll_setattr_ost(inode
, attr
);
1445 if (attr
->ia_valid
& ATTR_SIZE
)
1446 up_write(&lli
->lli_trunc_sem
);
1449 if (op_data
->op_ioepoch
) {
1450 rc1
= ll_setattr_done_writing(inode
, op_data
, mod
);
1454 ll_finish_md_op_data(op_data
);
1456 if (!S_ISDIR(inode
->i_mode
)) {
1457 mutex_lock(&inode
->i_mutex
);
1458 if ((attr
->ia_valid
& ATTR_SIZE
) && !hsm_import
)
1459 inode_dio_wait(inode
);
1462 ll_stats_ops_tally(ll_i2sbi(inode
), (attr
->ia_valid
& ATTR_SIZE
) ?
1463 LPROC_LL_TRUNC
: LPROC_LL_SETATTR
, 1);
1468 int ll_setattr(struct dentry
*de
, struct iattr
*attr
)
1470 int mode
= d_inode(de
)->i_mode
;
1472 if ((attr
->ia_valid
& (ATTR_CTIME
|ATTR_SIZE
|ATTR_MODE
)) ==
1473 (ATTR_CTIME
|ATTR_SIZE
|ATTR_MODE
))
1474 attr
->ia_valid
|= MDS_OPEN_OWNEROVERRIDE
;
1476 if (((attr
->ia_valid
& (ATTR_MODE
|ATTR_FORCE
|ATTR_SIZE
)) ==
1477 (ATTR_SIZE
|ATTR_MODE
)) &&
1478 (((mode
& S_ISUID
) && !(attr
->ia_mode
& S_ISUID
)) ||
1479 (((mode
& (S_ISGID
|S_IXGRP
)) == (S_ISGID
|S_IXGRP
)) &&
1480 !(attr
->ia_mode
& S_ISGID
))))
1481 attr
->ia_valid
|= ATTR_FORCE
;
1483 if ((attr
->ia_valid
& ATTR_MODE
) &&
1485 !(attr
->ia_mode
& S_ISUID
) &&
1486 !(attr
->ia_valid
& ATTR_KILL_SUID
))
1487 attr
->ia_valid
|= ATTR_KILL_SUID
;
1489 if ((attr
->ia_valid
& ATTR_MODE
) &&
1490 ((mode
& (S_ISGID
|S_IXGRP
)) == (S_ISGID
|S_IXGRP
)) &&
1491 !(attr
->ia_mode
& S_ISGID
) &&
1492 !(attr
->ia_valid
& ATTR_KILL_SGID
))
1493 attr
->ia_valid
|= ATTR_KILL_SGID
;
1495 return ll_setattr_raw(de
, attr
, false);
1498 int ll_statfs_internal(struct super_block
*sb
, struct obd_statfs
*osfs
,
1499 __u64 max_age
, __u32 flags
)
1501 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
1502 struct obd_statfs obd_osfs
;
1505 rc
= obd_statfs(NULL
, sbi
->ll_md_exp
, osfs
, max_age
, flags
);
1507 CERROR("md_statfs fails: rc = %d\n", rc
);
1511 osfs
->os_type
= sb
->s_magic
;
1513 CDEBUG(D_SUPER
, "MDC blocks %llu/%llu objects %llu/%llu\n",
1514 osfs
->os_bavail
, osfs
->os_blocks
, osfs
->os_ffree
,
1517 if (sbi
->ll_flags
& LL_SBI_LAZYSTATFS
)
1518 flags
|= OBD_STATFS_NODELAY
;
1520 rc
= obd_statfs_rqset(sbi
->ll_dt_exp
, &obd_osfs
, max_age
, flags
);
1522 CERROR("obd_statfs fails: rc = %d\n", rc
);
1526 CDEBUG(D_SUPER
, "OSC blocks %llu/%llu objects %llu/%llu\n",
1527 obd_osfs
.os_bavail
, obd_osfs
.os_blocks
, obd_osfs
.os_ffree
,
1530 osfs
->os_bsize
= obd_osfs
.os_bsize
;
1531 osfs
->os_blocks
= obd_osfs
.os_blocks
;
1532 osfs
->os_bfree
= obd_osfs
.os_bfree
;
1533 osfs
->os_bavail
= obd_osfs
.os_bavail
;
1535 /* If we don't have as many objects free on the OST as inodes
1536 * on the MDS, we reduce the total number of inodes to
1537 * compensate, so that the "inodes in use" number is correct.
1539 if (obd_osfs
.os_ffree
< osfs
->os_ffree
) {
1540 osfs
->os_files
= (osfs
->os_files
- osfs
->os_ffree
) +
1542 osfs
->os_ffree
= obd_osfs
.os_ffree
;
1547 int ll_statfs(struct dentry
*de
, struct kstatfs
*sfs
)
1549 struct super_block
*sb
= de
->d_sb
;
1550 struct obd_statfs osfs
;
1553 CDEBUG(D_VFSTRACE
, "VFS Op: at %llu jiffies\n", get_jiffies_64());
1554 ll_stats_ops_tally(ll_s2sbi(sb
), LPROC_LL_STAFS
, 1);
1556 /* Some amount of caching on the client is allowed */
1557 rc
= ll_statfs_internal(sb
, &osfs
,
1558 cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS
),
1563 statfs_unpack(sfs
, &osfs
);
1565 /* We need to downshift for all 32-bit kernels, because we can't
1566 * tell if the kernel is being called via sys_statfs64() or not.
1567 * Stop before overflowing f_bsize - in which case it is better
1568 * to just risk EOVERFLOW if caller is using old sys_statfs(). */
1569 if (sizeof(long) < 8) {
1570 while (osfs
.os_blocks
> ~0UL && sfs
->f_bsize
< 0x40000000) {
1573 osfs
.os_blocks
>>= 1;
1574 osfs
.os_bfree
>>= 1;
1575 osfs
.os_bavail
>>= 1;
1579 sfs
->f_blocks
= osfs
.os_blocks
;
1580 sfs
->f_bfree
= osfs
.os_bfree
;
1581 sfs
->f_bavail
= osfs
.os_bavail
;
1582 sfs
->f_fsid
= ll_s2sbi(sb
)->ll_fsid
;
1586 void ll_inode_size_lock(struct inode
*inode
)
1588 struct ll_inode_info
*lli
;
1590 LASSERT(!S_ISDIR(inode
->i_mode
));
1592 lli
= ll_i2info(inode
);
1593 mutex_lock(&lli
->lli_size_mutex
);
1596 void ll_inode_size_unlock(struct inode
*inode
)
1598 struct ll_inode_info
*lli
;
1600 lli
= ll_i2info(inode
);
1601 mutex_unlock(&lli
->lli_size_mutex
);
1604 void ll_update_inode(struct inode
*inode
, struct lustre_md
*md
)
1606 struct ll_inode_info
*lli
= ll_i2info(inode
);
1607 struct mdt_body
*body
= md
->body
;
1608 struct lov_stripe_md
*lsm
= md
->lsm
;
1609 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
1611 LASSERT ((lsm
!= NULL
) == ((body
->valid
& OBD_MD_FLEASIZE
) != 0));
1613 if (!lli
->lli_has_smd
&&
1614 !(sbi
->ll_flags
& LL_SBI_LAYOUT_LOCK
))
1615 cl_file_inode_init(inode
, md
);
1617 lli
->lli_maxbytes
= lsm
->lsm_maxbytes
;
1618 if (lli
->lli_maxbytes
> MAX_LFS_FILESIZE
)
1619 lli
->lli_maxbytes
= MAX_LFS_FILESIZE
;
1622 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
) {
1623 if (body
->valid
& OBD_MD_FLRMTPERM
)
1624 ll_update_remote_perm(inode
, md
->remote_perm
);
1626 #ifdef CONFIG_FS_POSIX_ACL
1627 else if (body
->valid
& OBD_MD_FLACL
) {
1628 spin_lock(&lli
->lli_lock
);
1629 if (lli
->lli_posix_acl
)
1630 posix_acl_release(lli
->lli_posix_acl
);
1631 lli
->lli_posix_acl
= md
->posix_acl
;
1632 spin_unlock(&lli
->lli_lock
);
1635 inode
->i_ino
= cl_fid_build_ino(&body
->fid1
,
1636 sbi
->ll_flags
& LL_SBI_32BIT_API
);
1637 inode
->i_generation
= cl_fid_build_gen(&body
->fid1
);
1639 if (body
->valid
& OBD_MD_FLATIME
) {
1640 if (body
->atime
> LTIME_S(inode
->i_atime
))
1641 LTIME_S(inode
->i_atime
) = body
->atime
;
1642 lli
->lli_lvb
.lvb_atime
= body
->atime
;
1644 if (body
->valid
& OBD_MD_FLMTIME
) {
1645 if (body
->mtime
> LTIME_S(inode
->i_mtime
)) {
1646 CDEBUG(D_INODE
, "setting ino %lu mtime from %lu to %llu\n",
1647 inode
->i_ino
, LTIME_S(inode
->i_mtime
),
1649 LTIME_S(inode
->i_mtime
) = body
->mtime
;
1651 lli
->lli_lvb
.lvb_mtime
= body
->mtime
;
1653 if (body
->valid
& OBD_MD_FLCTIME
) {
1654 if (body
->ctime
> LTIME_S(inode
->i_ctime
))
1655 LTIME_S(inode
->i_ctime
) = body
->ctime
;
1656 lli
->lli_lvb
.lvb_ctime
= body
->ctime
;
1658 if (body
->valid
& OBD_MD_FLMODE
)
1659 inode
->i_mode
= (inode
->i_mode
& S_IFMT
)|(body
->mode
& ~S_IFMT
);
1660 if (body
->valid
& OBD_MD_FLTYPE
)
1661 inode
->i_mode
= (inode
->i_mode
& ~S_IFMT
)|(body
->mode
& S_IFMT
);
1662 LASSERT(inode
->i_mode
!= 0);
1663 if (S_ISREG(inode
->i_mode
))
1664 inode
->i_blkbits
= min(PTLRPC_MAX_BRW_BITS
+ 1,
1665 LL_MAX_BLKSIZE_BITS
);
1667 inode
->i_blkbits
= inode
->i_sb
->s_blocksize_bits
;
1668 if (body
->valid
& OBD_MD_FLUID
)
1669 inode
->i_uid
= make_kuid(&init_user_ns
, body
->uid
);
1670 if (body
->valid
& OBD_MD_FLGID
)
1671 inode
->i_gid
= make_kgid(&init_user_ns
, body
->gid
);
1672 if (body
->valid
& OBD_MD_FLFLAGS
)
1673 inode
->i_flags
= ll_ext_to_inode_flags(body
->flags
);
1674 if (body
->valid
& OBD_MD_FLNLINK
)
1675 set_nlink(inode
, body
->nlink
);
1676 if (body
->valid
& OBD_MD_FLRDEV
)
1677 inode
->i_rdev
= old_decode_dev(body
->rdev
);
1679 if (body
->valid
& OBD_MD_FLID
) {
1680 /* FID shouldn't be changed! */
1681 if (fid_is_sane(&lli
->lli_fid
)) {
1682 LASSERTF(lu_fid_eq(&lli
->lli_fid
, &body
->fid1
),
1683 "Trying to change FID "DFID
1684 " to the "DFID
", inode %lu/%u(%p)\n",
1685 PFID(&lli
->lli_fid
), PFID(&body
->fid1
),
1686 inode
->i_ino
, inode
->i_generation
, inode
);
1688 lli
->lli_fid
= body
->fid1
;
1691 LASSERT(fid_seq(&lli
->lli_fid
) != 0);
1693 if (body
->valid
& OBD_MD_FLSIZE
) {
1694 if (exp_connect_som(ll_i2mdexp(inode
)) &&
1695 S_ISREG(inode
->i_mode
)) {
1696 struct lustre_handle lockh
;
1699 /* As it is possible a blocking ast has been processed
1700 * by this time, we need to check there is an UPDATE
1701 * lock on the client and set LLIF_MDS_SIZE_LOCK holding
1703 mode
= ll_take_md_lock(inode
, MDS_INODELOCK_UPDATE
,
1704 &lockh
, LDLM_FL_CBPENDING
,
1708 if (lli
->lli_flags
& (LLIF_DONE_WRITING
|
1709 LLIF_EPOCH_PENDING
|
1711 CERROR("ino %lu flags %u still has size authority! do not trust the size got from MDS\n",
1712 inode
->i_ino
, lli
->lli_flags
);
1714 /* Use old size assignment to avoid
1715 * deadlock bz14138 & bz14326 */
1716 i_size_write(inode
, body
->size
);
1717 spin_lock(&lli
->lli_lock
);
1718 lli
->lli_flags
|= LLIF_MDS_SIZE_LOCK
;
1719 spin_unlock(&lli
->lli_lock
);
1721 ldlm_lock_decref(&lockh
, mode
);
1724 /* Use old size assignment to avoid
1725 * deadlock bz14138 & bz14326 */
1726 i_size_write(inode
, body
->size
);
1728 CDEBUG(D_VFSTRACE
, "inode=%lu, updating i_size %llu\n",
1729 inode
->i_ino
, (unsigned long long)body
->size
);
1732 if (body
->valid
& OBD_MD_FLBLOCKS
)
1733 inode
->i_blocks
= body
->blocks
;
1736 if (body
->valid
& OBD_MD_FLMDSCAPA
) {
1737 LASSERT(md
->mds_capa
);
1738 ll_add_capa(inode
, md
->mds_capa
);
1740 if (body
->valid
& OBD_MD_FLOSSCAPA
) {
1741 LASSERT(md
->oss_capa
);
1742 ll_add_capa(inode
, md
->oss_capa
);
1745 if (body
->valid
& OBD_MD_TSTATE
) {
1746 if (body
->t_state
& MS_RESTORE
)
1747 lli
->lli_flags
|= LLIF_FILE_RESTORING
;
1751 void ll_read_inode2(struct inode
*inode
, void *opaque
)
1753 struct lustre_md
*md
= opaque
;
1754 struct ll_inode_info
*lli
= ll_i2info(inode
);
1756 CDEBUG(D_VFSTRACE
, "VFS Op:inode="DFID
"(%p)\n",
1757 PFID(&lli
->lli_fid
), inode
);
1759 LASSERT(!lli
->lli_has_smd
);
1761 /* Core attributes from the MDS first. This is a new inode, and
1762 * the VFS doesn't zero times in the core inode so we have to do
1763 * it ourselves. They will be overwritten by either MDS or OST
1764 * attributes - we just need to make sure they aren't newer. */
1765 LTIME_S(inode
->i_mtime
) = 0;
1766 LTIME_S(inode
->i_atime
) = 0;
1767 LTIME_S(inode
->i_ctime
) = 0;
1769 ll_update_inode(inode
, md
);
1771 /* OIDEBUG(inode); */
1773 if (S_ISREG(inode
->i_mode
)) {
1774 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
1776 inode
->i_op
= &ll_file_inode_operations
;
1777 inode
->i_fop
= sbi
->ll_fop
;
1778 inode
->i_mapping
->a_ops
= (struct address_space_operations
*)&ll_aops
;
1779 } else if (S_ISDIR(inode
->i_mode
)) {
1780 inode
->i_op
= &ll_dir_inode_operations
;
1781 inode
->i_fop
= &ll_dir_operations
;
1782 } else if (S_ISLNK(inode
->i_mode
)) {
1783 inode
->i_op
= &ll_fast_symlink_inode_operations
;
1785 inode
->i_op
= &ll_special_inode_operations
;
1787 init_special_inode(inode
, inode
->i_mode
,
1792 void ll_delete_inode(struct inode
*inode
)
1794 struct cl_inode_info
*lli
= cl_i2info(inode
);
1796 if (S_ISREG(inode
->i_mode
) && lli
->lli_clob
!= NULL
)
1797 /* discard all dirty pages before truncating them, required by
1798 * osc_extent implementation at LU-1030. */
1799 cl_sync_file_range(inode
, 0, OBD_OBJECT_EOF
,
1800 CL_FSYNC_DISCARD
, 1);
1802 truncate_inode_pages_final(&inode
->i_data
);
1804 /* Workaround for LU-118 */
1805 if (inode
->i_data
.nrpages
) {
1806 spin_lock_irq(&inode
->i_data
.tree_lock
);
1807 spin_unlock_irq(&inode
->i_data
.tree_lock
);
1808 LASSERTF(inode
->i_data
.nrpages
== 0,
1809 "inode=%lu/%u(%p) nrpages=%lu, see http://jira.whamcloud.com/browse/LU-118\n",
1810 inode
->i_ino
, inode
->i_generation
, inode
,
1811 inode
->i_data
.nrpages
);
1813 /* Workaround end */
1815 ll_clear_inode(inode
);
1819 int ll_iocontrol(struct inode
*inode
, struct file
*file
,
1820 unsigned int cmd
, unsigned long arg
)
1822 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
1823 struct ptlrpc_request
*req
= NULL
;
1827 case FSFILT_IOC_GETFLAGS
: {
1828 struct mdt_body
*body
;
1829 struct md_op_data
*op_data
;
1831 op_data
= ll_prep_md_op_data(NULL
, inode
, NULL
, NULL
,
1832 0, 0, LUSTRE_OPC_ANY
,
1834 if (IS_ERR(op_data
))
1835 return PTR_ERR(op_data
);
1837 op_data
->op_valid
= OBD_MD_FLFLAGS
;
1838 rc
= md_getattr(sbi
->ll_md_exp
, op_data
, &req
);
1839 ll_finish_md_op_data(op_data
);
1841 CERROR("failure %d inode %lu\n", rc
, inode
->i_ino
);
1845 body
= req_capsule_server_get(&req
->rq_pill
, &RMF_MDT_BODY
);
1847 flags
= body
->flags
;
1849 ptlrpc_req_finished(req
);
1851 return put_user(flags
, (int *)arg
);
1853 case FSFILT_IOC_SETFLAGS
: {
1854 struct lov_stripe_md
*lsm
;
1855 struct obd_info oinfo
= { { { 0 } } };
1856 struct md_op_data
*op_data
;
1858 if (get_user(flags
, (int *)arg
))
1861 op_data
= ll_prep_md_op_data(NULL
, inode
, NULL
, NULL
, 0, 0,
1862 LUSTRE_OPC_ANY
, NULL
);
1863 if (IS_ERR(op_data
))
1864 return PTR_ERR(op_data
);
1866 ((struct ll_iattr
*)&op_data
->op_attr
)->ia_attr_flags
= flags
;
1867 op_data
->op_attr
.ia_valid
|= ATTR_ATTR_FLAG
;
1868 rc
= md_setattr(sbi
->ll_md_exp
, op_data
,
1869 NULL
, 0, NULL
, 0, &req
, NULL
);
1870 ll_finish_md_op_data(op_data
);
1871 ptlrpc_req_finished(req
);
1875 inode
->i_flags
= ll_ext_to_inode_flags(flags
);
1877 lsm
= ccc_inode_lsm_get(inode
);
1878 if (!lsm_has_objects(lsm
)) {
1879 ccc_inode_lsm_put(inode
, lsm
);
1883 OBDO_ALLOC(oinfo
.oi_oa
);
1885 ccc_inode_lsm_put(inode
, lsm
);
1889 oinfo
.oi_oa
->o_oi
= lsm
->lsm_oi
;
1890 oinfo
.oi_oa
->o_flags
= flags
;
1891 oinfo
.oi_oa
->o_valid
= OBD_MD_FLID
| OBD_MD_FLFLAGS
|
1893 oinfo
.oi_capa
= ll_mdscapa_get(inode
);
1894 obdo_set_parent_fid(oinfo
.oi_oa
, &ll_i2info(inode
)->lli_fid
);
1895 rc
= obd_setattr_rqset(sbi
->ll_dt_exp
, &oinfo
, NULL
);
1896 capa_put(oinfo
.oi_capa
);
1897 OBDO_FREE(oinfo
.oi_oa
);
1898 ccc_inode_lsm_put(inode
, lsm
);
1900 if (rc
&& rc
!= -EPERM
&& rc
!= -EACCES
)
1901 CERROR("osc_setattr_async fails: rc = %d\n", rc
);
1912 int ll_flush_ctx(struct inode
*inode
)
1914 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
1916 CDEBUG(D_SEC
, "flush context for user %d\n",
1917 from_kuid(&init_user_ns
, current_uid()));
1919 obd_set_info_async(NULL
, sbi
->ll_md_exp
,
1920 sizeof(KEY_FLUSH_CTX
), KEY_FLUSH_CTX
,
1922 obd_set_info_async(NULL
, sbi
->ll_dt_exp
,
1923 sizeof(KEY_FLUSH_CTX
), KEY_FLUSH_CTX
,
1928 /* umount -f client means force down, don't save state */
1929 void ll_umount_begin(struct super_block
*sb
)
1931 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
1932 struct obd_device
*obd
;
1933 struct obd_ioctl_data
*ioc_data
;
1935 CDEBUG(D_VFSTRACE
, "VFS Op: superblock %p count %d active %d\n", sb
,
1936 sb
->s_count
, atomic_read(&sb
->s_active
));
1938 obd
= class_exp2obd(sbi
->ll_md_exp
);
1940 CERROR("Invalid MDC connection handle %#llx\n",
1941 sbi
->ll_md_exp
->exp_handle
.h_cookie
);
1946 obd
= class_exp2obd(sbi
->ll_dt_exp
);
1948 CERROR("Invalid LOV connection handle %#llx\n",
1949 sbi
->ll_dt_exp
->exp_handle
.h_cookie
);
1954 ioc_data
= kzalloc(sizeof(*ioc_data
), GFP_NOFS
);
1956 obd_iocontrol(IOC_OSC_SET_ACTIVE
, sbi
->ll_md_exp
,
1957 sizeof(*ioc_data
), ioc_data
, NULL
);
1959 obd_iocontrol(IOC_OSC_SET_ACTIVE
, sbi
->ll_dt_exp
,
1960 sizeof(*ioc_data
), ioc_data
, NULL
);
1962 OBD_FREE_PTR(ioc_data
);
1965 /* Really, we'd like to wait until there are no requests outstanding,
1966 * and then continue. For now, we just invalidate the requests,
1967 * schedule() and sleep one second if needed, and hope.
1972 int ll_remount_fs(struct super_block
*sb
, int *flags
, char *data
)
1974 struct ll_sb_info
*sbi
= ll_s2sbi(sb
);
1975 char *profilenm
= get_profile_name(sb
);
1979 if ((*flags
& MS_RDONLY
) != (sb
->s_flags
& MS_RDONLY
)) {
1980 read_only
= *flags
& MS_RDONLY
;
1981 err
= obd_set_info_async(NULL
, sbi
->ll_md_exp
,
1982 sizeof(KEY_READ_ONLY
),
1983 KEY_READ_ONLY
, sizeof(read_only
),
1986 LCONSOLE_WARN("Failed to remount %s %s (%d)\n",
1987 profilenm
, read_only
?
1988 "read-only" : "read-write", err
);
1993 sb
->s_flags
|= MS_RDONLY
;
1995 sb
->s_flags
&= ~MS_RDONLY
;
1997 if (sbi
->ll_flags
& LL_SBI_VERBOSE
)
1998 LCONSOLE_WARN("Remounted %s %s\n", profilenm
,
1999 read_only
? "read-only" : "read-write");
2004 int ll_prep_inode(struct inode
**inode
, struct ptlrpc_request
*req
,
2005 struct super_block
*sb
, struct lookup_intent
*it
)
2007 struct ll_sb_info
*sbi
= NULL
;
2008 struct lustre_md md
;
2011 LASSERT(*inode
|| sb
);
2012 sbi
= sb
? ll_s2sbi(sb
) : ll_i2sbi(*inode
);
2013 rc
= md_get_lustre_md(sbi
->ll_md_exp
, req
, sbi
->ll_dt_exp
,
2014 sbi
->ll_md_exp
, &md
);
2019 ll_update_inode(*inode
, &md
);
2021 LASSERT(sb
!= NULL
);
2024 * At this point server returns to client's same fid as client
2025 * generated for creating. So using ->fid1 is okay here.
2027 LASSERT(fid_is_sane(&md
.body
->fid1
));
2029 *inode
= ll_iget(sb
, cl_fid_build_ino(&md
.body
->fid1
,
2030 sbi
->ll_flags
& LL_SBI_32BIT_API
),
2032 if (*inode
== NULL
|| IS_ERR(*inode
)) {
2033 #ifdef CONFIG_FS_POSIX_ACL
2035 posix_acl_release(md
.posix_acl
);
2036 md
.posix_acl
= NULL
;
2039 rc
= IS_ERR(*inode
) ? PTR_ERR(*inode
) : -ENOMEM
;
2041 CERROR("new_inode -fatal: rc %d\n", rc
);
2046 /* Handling piggyback layout lock.
2047 * Layout lock can be piggybacked by getattr and open request.
2048 * The lsm can be applied to inode only if it comes with a layout lock
2049 * otherwise correct layout may be overwritten, for example:
2050 * 1. proc1: mdt returns a lsm but not granting layout
2051 * 2. layout was changed by another client
2052 * 3. proc2: refresh layout and layout lock granted
2053 * 4. proc1: to apply a stale layout */
2054 if (it
!= NULL
&& it
->d
.lustre
.it_lock_mode
!= 0) {
2055 struct lustre_handle lockh
;
2056 struct ldlm_lock
*lock
;
2058 lockh
.cookie
= it
->d
.lustre
.it_lock_handle
;
2059 lock
= ldlm_handle2lock(&lockh
);
2060 LASSERT(lock
!= NULL
);
2061 if (ldlm_has_layout(lock
)) {
2062 struct cl_object_conf conf
;
2064 memset(&conf
, 0, sizeof(conf
));
2065 conf
.coc_opc
= OBJECT_CONF_SET
;
2066 conf
.coc_inode
= *inode
;
2067 conf
.coc_lock
= lock
;
2068 conf
.u
.coc_md
= &md
;
2069 (void)ll_layout_conf(*inode
, &conf
);
2071 LDLM_LOCK_PUT(lock
);
2076 obd_free_memmd(sbi
->ll_dt_exp
, &md
.lsm
);
2077 md_free_lustre_md(sbi
->ll_md_exp
, &md
);
2081 int ll_obd_statfs(struct inode
*inode
, void *arg
)
2083 struct ll_sb_info
*sbi
= NULL
;
2084 struct obd_export
*exp
;
2086 struct obd_ioctl_data
*data
= NULL
;
2096 sbi
= ll_i2sbi(inode
);
2102 rc
= obd_ioctl_getdata(&buf
, &len
, arg
);
2107 if (!data
->ioc_inlbuf1
|| !data
->ioc_inlbuf2
||
2108 !data
->ioc_pbuf1
|| !data
->ioc_pbuf2
) {
2113 if (data
->ioc_inllen1
!= sizeof(__u32
) ||
2114 data
->ioc_inllen2
!= sizeof(__u32
) ||
2115 data
->ioc_plen1
!= sizeof(struct obd_statfs
) ||
2116 data
->ioc_plen2
!= sizeof(struct obd_uuid
)) {
2121 memcpy(&type
, data
->ioc_inlbuf1
, sizeof(__u32
));
2122 if (type
& LL_STATFS_LMV
)
2123 exp
= sbi
->ll_md_exp
;
2124 else if (type
& LL_STATFS_LOV
)
2125 exp
= sbi
->ll_dt_exp
;
2131 flags
= (type
& LL_STATFS_NODELAY
) ? OBD_STATFS_NODELAY
: 0;
2132 rc
= obd_iocontrol(IOC_OBD_STATFS
, exp
, len
, buf
, &flags
);
2137 obd_ioctl_freedata(buf
, len
);
2141 int ll_process_config(struct lustre_cfg
*lcfg
)
2145 struct lprocfs_static_vars lvars
;
2149 lprocfs_llite_init_vars(&lvars
);
2151 /* The instance name contains the sb: lustre-client-aacfe000 */
2152 ptr
= strrchr(lustre_cfg_string(lcfg
, 0), '-');
2153 if (!ptr
|| !*(++ptr
))
2155 if (sscanf(ptr
, "%lx", &x
) != 1)
2158 /* This better be a real Lustre superblock! */
2159 LASSERT(s2lsi((struct super_block
*)sb
)->lsi_lmd
->lmd_magic
== LMD_MAGIC
);
2161 /* Note we have not called client_common_fill_super yet, so
2162 proc fns must be able to handle that! */
2163 rc
= class_process_proc_param(PARAM_LLITE
, lvars
.obd_vars
,
2170 /* this function prepares md_op_data hint for passing ot down to MD stack. */
2171 struct md_op_data
*ll_prep_md_op_data(struct md_op_data
*op_data
,
2172 struct inode
*i1
, struct inode
*i2
,
2173 const char *name
, int namelen
,
2174 int mode
, __u32 opc
, void *data
)
2176 LASSERT(i1
!= NULL
);
2178 if (namelen
> ll_i2sbi(i1
)->ll_namelen
)
2179 return ERR_PTR(-ENAMETOOLONG
);
2181 if (op_data
== NULL
)
2182 op_data
= kzalloc(sizeof(*op_data
), GFP_NOFS
);
2184 if (op_data
== NULL
)
2185 return ERR_PTR(-ENOMEM
);
2187 ll_i2gids(op_data
->op_suppgids
, i1
, i2
);
2188 op_data
->op_fid1
= *ll_inode2fid(i1
);
2189 op_data
->op_capa1
= ll_mdscapa_get(i1
);
2192 op_data
->op_fid2
= *ll_inode2fid(i2
);
2193 op_data
->op_capa2
= ll_mdscapa_get(i2
);
2195 fid_zero(&op_data
->op_fid2
);
2196 op_data
->op_capa2
= NULL
;
2199 op_data
->op_name
= name
;
2200 op_data
->op_namelen
= namelen
;
2201 op_data
->op_mode
= mode
;
2202 op_data
->op_mod_time
= get_seconds();
2203 op_data
->op_fsuid
= from_kuid(&init_user_ns
, current_fsuid());
2204 op_data
->op_fsgid
= from_kgid(&init_user_ns
, current_fsgid());
2205 op_data
->op_cap
= cfs_curproc_cap_pack();
2206 op_data
->op_bias
= 0;
2207 op_data
->op_cli_flags
= 0;
2208 if ((opc
== LUSTRE_OPC_CREATE
) && (name
!= NULL
) &&
2209 filename_is_volatile(name
, namelen
, NULL
))
2210 op_data
->op_bias
|= MDS_CREATE_VOLATILE
;
2211 op_data
->op_opc
= opc
;
2212 op_data
->op_mds
= 0;
2213 op_data
->op_data
= data
;
2215 /* If the file is being opened after mknod() (normally due to NFS)
2216 * try to use the default stripe data from parent directory for
2217 * allocating OST objects. Try to pass the parent FID to MDS. */
2218 if (opc
== LUSTRE_OPC_CREATE
&& i1
== i2
&& S_ISREG(i2
->i_mode
) &&
2219 !ll_i2info(i2
)->lli_has_smd
) {
2220 struct ll_inode_info
*lli
= ll_i2info(i2
);
2222 spin_lock(&lli
->lli_lock
);
2223 if (likely(!lli
->lli_has_smd
&& !fid_is_zero(&lli
->lli_pfid
)))
2224 op_data
->op_fid1
= lli
->lli_pfid
;
2225 spin_unlock(&lli
->lli_lock
);
2226 /** We ignore parent's capability temporary. */
2229 /* When called by ll_setattr_raw, file is i1. */
2230 if (LLIF_DATA_MODIFIED
& ll_i2info(i1
)->lli_flags
)
2231 op_data
->op_bias
|= MDS_DATA_MODIFIED
;
2236 void ll_finish_md_op_data(struct md_op_data
*op_data
)
2238 capa_put(op_data
->op_capa1
);
2239 capa_put(op_data
->op_capa2
);
2240 OBD_FREE_PTR(op_data
);
2243 int ll_show_options(struct seq_file
*seq
, struct dentry
*dentry
)
2245 struct ll_sb_info
*sbi
;
2247 LASSERT((seq
!= NULL
) && (dentry
!= NULL
));
2248 sbi
= ll_s2sbi(dentry
->d_sb
);
2250 if (sbi
->ll_flags
& LL_SBI_NOLCK
)
2251 seq_puts(seq
, ",nolock");
2253 if (sbi
->ll_flags
& LL_SBI_FLOCK
)
2254 seq_puts(seq
, ",flock");
2256 if (sbi
->ll_flags
& LL_SBI_LOCALFLOCK
)
2257 seq_puts(seq
, ",localflock");
2259 if (sbi
->ll_flags
& LL_SBI_USER_XATTR
)
2260 seq_puts(seq
, ",user_xattr");
2262 if (sbi
->ll_flags
& LL_SBI_LAZYSTATFS
)
2263 seq_puts(seq
, ",lazystatfs");
2265 if (sbi
->ll_flags
& LL_SBI_USER_FID2PATH
)
2266 seq_puts(seq
, ",user_fid2path");
2272 * Get obd name by cmd, and copy out to user space
2274 int ll_get_obd_name(struct inode
*inode
, unsigned int cmd
, unsigned long arg
)
2276 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
2277 struct obd_device
*obd
;
2279 if (cmd
== OBD_IOC_GETDTNAME
)
2280 obd
= class_exp2obd(sbi
->ll_dt_exp
);
2281 else if (cmd
== OBD_IOC_GETMDNAME
)
2282 obd
= class_exp2obd(sbi
->ll_md_exp
);
2289 if (copy_to_user((void *)arg
, obd
->obd_name
,
2290 strlen(obd
->obd_name
) + 1))
2297 * Get lustre file system name by \a sbi. If \a buf is provided(non-NULL), the
2298 * fsname will be returned in this buffer; otherwise, a static buffer will be
2299 * used to store the fsname and returned to caller.
2301 char *ll_get_fsname(struct super_block
*sb
, char *buf
, int buflen
)
2303 static char fsname_static
[MTI_NAME_MAXLEN
];
2304 struct lustre_sb_info
*lsi
= s2lsi(sb
);
2309 /* this means the caller wants to use static buffer
2310 * and it doesn't care about race. Usually this is
2311 * in error reporting path */
2312 buf
= fsname_static
;
2313 buflen
= sizeof(fsname_static
);
2316 len
= strlen(lsi
->lsi_lmd
->lmd_profile
);
2317 ptr
= strrchr(lsi
->lsi_lmd
->lmd_profile
, '-');
2318 if (ptr
&& (strcmp(ptr
, "-client") == 0))
2321 if (unlikely(len
>= buflen
))
2323 strncpy(buf
, lsi
->lsi_lmd
->lmd_profile
, len
);
2329 void ll_dirty_page_discard_warn(struct page
*page
, int ioret
)
2331 char *buf
, *path
= NULL
;
2332 struct dentry
*dentry
= NULL
;
2333 struct ccc_object
*obj
= cl_inode2ccc(page
->mapping
->host
);
2335 /* this can be called inside spin lock so use GFP_ATOMIC. */
2336 buf
= (char *)__get_free_page(GFP_ATOMIC
);
2338 dentry
= d_find_alias(page
->mapping
->host
);
2340 path
= dentry_path_raw(dentry
, buf
, PAGE_SIZE
);
2344 "%s: dirty page discard: %s/fid: " DFID
"/%s may get corrupted (rc %d)\n",
2345 ll_get_fsname(page
->mapping
->host
->i_sb
, NULL
, 0),
2346 s2lsi(page
->mapping
->host
->i_sb
)->lsi_lmd
->lmd_dev
,
2347 PFID(&obj
->cob_header
.coh_lu
.loh_fid
),
2348 (path
&& !IS_ERR(path
)) ? path
: "", ioret
);
2354 free_page((unsigned long)buf
);